{"version":3,"sources":["jsdelivr-header.js","/npm/@devexpress/dx-chart-core@4.0.11/src/constants.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/utils/scale.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/plugins/scale/computeds.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/plugins/layout-manager/computeds.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/plugins/axis/computeds.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/plugins/series/computeds.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/plugins/stack/computeds.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/plugins/animation/computeds.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/utils/hover-state.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/utils/common.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/plugins/tooltip/computeds.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/plugins/zoom-and-pan/computeds.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/plugins/controller-component/computeds.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/utils/series.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/utils/legend.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/utils/event-tracker.ts","/npm/@devexpress/dx-chart-core@4.0.11/src/utils/animation.ts"],"names":[],"mappings":"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","file":"/npm/@devexpress/dx-chart-core@4.0.11/dist/dx-chart-core.es.js/+esm","sourceRoot":"","sourcesContent":["/**\n * Bundled by jsDelivr using Rollup v2.79.2 and Terser v5.39.0.\n * Original file: /npm/@devexpress/dx-chart-core@4.0.11/dist/dx-chart-core.es.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/** @internal */\nexport const HORIZONTAL = 'horizontal';\n/** @internal */\nexport const VERTICAL = 'vertical';\n/** @internal */\nexport const TOP = 'top';\n/** @internal */\nexport const BOTTOM = 'bottom';\n/** @internal */\nexport const LEFT = 'left';\n/** @internal */\nexport const RIGHT = 'right';\n/** @internal */\nexport const MIDDLE = 'middle';\n/** @internal */\nexport const END = 'end';\n/** @internal */\nexport const START = 'start';\n/** @internal */\nexport const LINEAR = 'linear';\n/** @internal */\nexport const BAND = 'band';\n/** @internal */\nexport const ARGUMENT_DOMAIN = 'argument-domain';\n/** @internal */\nexport const VALUE_DOMAIN = 'value-domain';\n/** @internal */\nexport const HOVERED = 'hovered';\n/** @internal */\nexport const SELECTED = 'selected';\n/** @internal */\nexport const DIFFERENCE = 3;\n","import {\n scaleLinear as d3ScaleLinear, scaleBand as d3ScaleBand,\n} from 'd3-scale';\nimport {\n ARGUMENT_DOMAIN, VALUE_DOMAIN,\n} from '../constants';\nimport {\n ScaleObject, FactoryFn, DomainInfo, NumberArray, DomainBounds, DomainItems,\n} from '../types';\n\n/** @internal */\nexport const scaleLinear: FactoryFn = d3ScaleLinear as any;\n\nexport const scaleBand: FactoryFn = () => (\n d3ScaleBand().paddingInner(0.3).paddingOuter(0.15) as any\n);\n\n/** @internal */\nexport const isHorizontal = (name: string, rotated: boolean) => (\n name === ARGUMENT_DOMAIN === !rotated\n);\n\n// tslint:disable-next-line: ban-types\nconst makeScaleHelper = (linear: T, band: T) => {\n const func: any = (scale: ScaleObject, ...args: any[]) => {\n const choosen = 'bandwidth' in scale ? band : linear;\n return choosen(scale, ...args);\n };\n return func as T;\n};\n\nconst getLinearScaleWidth = (_: ScaleObject) => 0;\n\nconst getBandScaleWidth = (scale: ScaleObject) => scale.bandwidth!();\n\n/** @internal */\nexport const getWidth = makeScaleHelper(getLinearScaleWidth, getBandScaleWidth);\n\n/** @internal */\nexport const getValueDomainName = (name?: string) => name || VALUE_DOMAIN;\n\nconst floatsEqual = (a: number, b: number) => Math.abs(a - b) < Number.EPSILON;\n\n/** @internal */\nexport const rangesEqual = (r1: Readonly, r2: Readonly) =>\n floatsEqual(r1[0], r2[0]) && floatsEqual(r1[1], r2[1]);\n\nconst wrapLinearScale = (scale: ScaleObject) => scale;\n\nconst wrapBandScale = (scale: ScaleObject): ScaleObject => {\n const ret: any = (value: any) => scale(value) + scale.bandwidth!() / 2;\n Object.assign(ret, scale);\n return ret;\n};\n\nconst wrapScale = makeScaleHelper(wrapLinearScale, wrapBandScale);\n\n/** @internal */\nexport const makeScale = ({ factory, domain }: DomainInfo, range: NumberArray) => {\n const scale = (factory || scaleLinear)().domain(domain).range(range);\n return wrapScale(scale);\n};\n\n// It is implicitly supposed that Chart can accept any d3 scale. It is wrong.\n// The followings notes show that. d3 scales are not seamlessly interchangeable themselves\n// (i.e. band scale has no \"invert\", continuous scale has no \"bandwidth\").\n// We have to use \"adapters\" to mitigate the differences.\n// Hence Chart can actually accept any object that matches \"adapter\" interface.\n// TODO: We should update reference accordingly. There might be breaking changes though.\n\nconst scaleLinearBounds = (scale: ScaleObject, bounds: DomainBounds): NumberArray => (\n bounds.map(scale) as NumberArray\n);\n\n// There is an issue - when range is \"inverted\" values are scaled incorrectly.\n// scaleBand().domain(['a', 'b', 'c']).range([0, 60])('b') === 20\n// scaleBand().domain(['a', 'b', 'c']).range([60, 0])('b') === 20 (should be 40)\nconst scaleBandBounds = (scale: ScaleObject, bounds: DomainBounds): NumberArray => {\n const cleanScale = scale.copy().paddingInner!(0).paddingOuter!(0);\n const fullRange = scale.range();\n const sign = Math.sign(fullRange[1] - fullRange[0]);\n return sign >= 0\n ? [cleanScale(bounds[0]), cleanScale(bounds[1]) + cleanScale.bandwidth!()]\n : [cleanScale(bounds[0]) + cleanScale.bandwidth!(), cleanScale(bounds[1])];\n};\n\nconst moveLinearScaleBounds = (\n scale: ScaleObject, bounds: DomainBounds, delta: number,\n): DomainBounds => {\n const fullRange = scale.range();\n const sign = Math.sign(fullRange[1] - fullRange[0]);\n const range = scaleLinearBounds(scale, bounds);\n let r0 = range[0] + delta;\n let r1 = range[1] + delta;\n // Check if new range is outside of the left border.\n if (Math.sign(r0 - fullRange[0]) !== sign) {\n r0 = fullRange[0];\n r1 = r0 + range[1] - range[0];\n }\n // Check if new range is outside of the right border.\n if (Math.sign(fullRange[1] - r1) !== sign) {\n r1 = fullRange[1];\n r0 = r1 - range[1] + range[0];\n }\n const newBounds: DomainBounds = [scale.invert!(r0), scale.invert!(r1)];\n return rangesEqual(bounds, newBounds) ? bounds : newBounds;\n};\n\n// This is pointer \"delta\" processing specific for \"band\" scale.\n// If pointer delta is significantly smaller than band size (0.3) then movement should be skipped\n// and current delta should be added to a next one (from a new \"move\" event).\n// Now there is no code that accumulates deltas.\n// In order to allow band scrolling at least somehow the following is applied - if pointer delta\n// is at least greater than 30 pixel then minimal movement is performed.\n// TODO: Make proper delta accumulation!\nconst adjustBandScaleMoveStep = (delta: number, step: number) => {\n const ratio = Math.abs(delta / step);\n const sign = Math.sign(delta / step);\n if (ratio >= 0.5) {\n return sign * Math.round(ratio);\n }\n if (ratio >= 0.3) {\n return sign;\n }\n if (Math.abs(delta) > 30) {\n return sign;\n }\n return 0;\n};\n\n// Band case is processed separately to preserve categories count in the bounds range.\n// If common inversion mechanism is used start and end bounds cannot be inverted independently\n// because of rounding issues which may add or remove categories to the new bounds.\nconst moveBandScaleBounds = (\n scale: ScaleObject, bounds: DomainBounds, delta: number,\n): DomainBounds => {\n const domain = scale.domain();\n const fullRange = scale.range();\n const step = (fullRange[1] - fullRange[0]) / domain.length;\n const rangeStep = adjustBandScaleMoveStep(delta, step);\n if (rangeStep === 0) {\n return bounds;\n }\n const range = scaleBounds(scale, bounds);\n const range0 = Math.round((range[0] - fullRange[0]) / step);\n const range1 = range0 + Math.round((range[1] - range[0]) / step) - 1;\n let new0 = range0 + rangeStep;\n let new1 = range1 + rangeStep;\n if (new0 < 0) {\n new0 = 0;\n new1 = new0 + range1 - range0;\n }\n if (new1 > domain.length - 1) {\n new1 = domain.length - 1;\n new0 = new1 - range1 + range0;\n }\n if (new0 === range0 || new1 === range1) {\n return bounds;\n }\n return [domain[new0], domain[new1]];\n};\n\n// Defines how much linear scale can be zoomed it.\n// I.e. if original scale domain has size of 1, then fully zoomed scale domain has size\n// of 1 / LINEAR_SCALE_ZOOMING_THRESHOLD.\nconst LINEAR_SCALE_ZOOMING_THRESHOLD = 1000;\n\nconst growLinearScaleBounds = (\n scale: ScaleObject, bounds: DomainBounds, delta: number, anchor: number,\n): DomainBounds => {\n const fullRange = scale.range();\n const minRangeThreshold = (fullRange[1] - fullRange[0]) / LINEAR_SCALE_ZOOMING_THRESHOLD;\n const sign = Math.sign(fullRange[1] - fullRange[0]);\n const range = scaleBounds(scale, bounds);\n // If zooming in and initial range is already too small then do nothing.\n if (delta > 0 && Math.abs(range[1] - range[0]) <= Math.abs(minRangeThreshold)) {\n return bounds;\n }\n // If zooming out and initial range is already too large then do nothing.\n if (delta < 0 && Math.abs(range[1] - range[0]) >= Math.abs(fullRange[1] - fullRange[0])) {\n return bounds;\n }\n const t = Math.abs((anchor - range[0]) / (range[1] - range[0]));\n let r0 = range[0] + sign * delta * 2 * t;\n let r1 = range[1] - sign * delta * 2 * (1 - t);\n // If new range is outside of the left border then clamp it.\n if (Math.sign(r0 - fullRange[0]) !== sign) {\n r0 = fullRange[0];\n }\n // If new range is outside of the right border then clamp it.\n if (Math.sign(fullRange[1] - r1) !== sign) {\n r1 = fullRange[1];\n }\n // If new range is too small then make it no less than minimal available.\n if (Math.sign(r1 - r0) !== sign || Math.abs(r1 - r0) < Math.abs(minRangeThreshold)) {\n if (Math.abs(r0 - range[0]) < Math.abs(minRangeThreshold / 2)) {\n // Dock it to the start.\n r0 = range[0];\n r1 = r0 + minRangeThreshold;\n } else if (Math.abs(r1 - range[1]) < Math.abs(minRangeThreshold / 2)) {\n // Dock it to the end.\n r1 = range[1];\n r0 = r1 - minRangeThreshold;\n } else {\n // Dock it to the anchor.\n r0 = anchor - minRangeThreshold / 2;\n r1 = anchor + minRangeThreshold / 2;\n }\n }\n const newBounds: DomainBounds = [scale.invert!(r0), scale.invert!(r1)];\n return rangesEqual(bounds, newBounds) ? bounds : newBounds;\n};\n\nconst growBandScaleBounds = (\n scale: ScaleObject, bounds: DomainBounds, delta: number, anchor: number,\n): DomainBounds => {\n const domain = scale.domain();\n const fullRange = scale.range();\n const step = (fullRange[1] - fullRange[0]) / domain.length;\n const range = scaleBounds(scale, bounds);\n const range0 = Math.round((range[0] - fullRange[0]) / step);\n const range1 = range0 + Math.round((range[1] - range[0]) / step) - 1;\n // Let it be always 1 for now.\n const rangeStep = Math.sign(delta);\n if (\n (rangeStep === 0) ||\n (rangeStep > 0 && range0 === range1) ||\n (rangeStep < 0 && range0 === 0 && range1 === domain.length - 1)\n ) {\n return bounds;\n }\n const t = Math.abs((anchor - range[0]) / (range[1] - range[0]));\n let new0 = range0 + Math.round(rangeStep * 2 * t);\n let new1 = range1 - Math.round(rangeStep * 2 * (1 - t));\n if (new0 < 0) {\n new0 = 0;\n }\n if (new1 > domain.length - 1) {\n new1 = domain.length - 1;\n }\n if (new0 > new1) {\n if (t <= 0.5) {\n new1 = new0;\n } else {\n new0 = new1;\n }\n }\n if (new0 === range0 && new1 === range1) {\n return bounds;\n }\n return [domain[new0], domain[new1]];\n};\n\nconst invertLinearScaleBounds = (scale: ScaleObject, range: NumberArray): DomainBounds => {\n const fullRange = scale.range();\n const match = Math.sign(fullRange[1] - fullRange[0]) === Math.sign(range[1] - range[0]);\n return [\n scale.invert!(range[match ? 0 : 1]),\n scale.invert!(range[match ? 1 : 0]),\n ];\n};\n\nconst matchPointToBand = (domain: DomainItems, range: NumberArray, p: number) => {\n const i = Math.floor(domain.length * (p - range[0]) / (range[1] - range[0]));\n return domain[Math.min(i, domain.length - 1)];\n};\n\nconst invertBandScaleBounds = (scale: ScaleObject, range: NumberArray): DomainBounds => {\n const domain = scale.domain();\n const fullRange = scale.range();\n return [\n matchPointToBand(domain, fullRange, range[0]),\n matchPointToBand(domain, fullRange, range[1]),\n ];\n};\n\n// Though these functions are used only in *Viewport* plugin (and so should be placed right there),\n// they reside here so that internal scale specifics (*getWidth*)\n// are encapsulated in this utility file.\n/** @internal */\nexport const scaleBounds = makeScaleHelper(scaleLinearBounds, scaleBandBounds);\n/** @internal */\nexport const moveBounds = makeScaleHelper(moveLinearScaleBounds, moveBandScaleBounds);\n// \"scaleBounds\" would be a better name but \"scale\" is already occupied.\n/** @internal */\nexport const growBounds = makeScaleHelper(growLinearScaleBounds, growBandScaleBounds);\n/** @internal */\nexport const invertBoundsRange = makeScaleHelper(invertLinearScaleBounds, invertBandScaleBounds);\n","import { extent } from 'd3-array';\nimport {\n getValueDomainName, scaleLinear, scaleBand, rangesEqual, makeScale,\n} from '../../utils/scale';\nimport { ARGUMENT_DOMAIN, VALUE_DOMAIN } from '../../constants';\nimport {\n Series, PointList, DomainItems, DomainInfoCache, BuildScalesFn, DomainInfo, DomainOptions,\n AddDomainFn, MergeDomainsFn, GetItemFn, GetDomainItemsFn,\n FactoryFn, ExtendDomainsFn, NumberArray,\n} from '../../types';\n\nconst makeDomain = ({ factory, modifyDomain }: DomainOptions): DomainInfo => ({\n domain: [],\n factory,\n isDiscrete: !!(factory && isDiscrete(factory)),\n modifyDomain,\n});\n\n/** @internal */\nexport const defaultDomains: DomainInfoCache = {\n [ARGUMENT_DOMAIN]: makeDomain({}),\n [VALUE_DOMAIN]: makeDomain({}),\n};\n/** @internal */\nexport const addDomain: AddDomainFn = (domains, name, options) => ({\n ...domains,\n [name]: makeDomain(options),\n});\n\nconst mergeContinuousDomains: MergeDomainsFn = (domain, items) => {\n const newDomain = extent([...domain, ...items]);\n return rangesEqual(newDomain as any, domain as any) ? domain : newDomain;\n};\n\nconst mergeDiscreteDomains: MergeDomainsFn = (domain, items) => {\n const newDomain = Array.from(new Set([...domain, ...items]));\n return newDomain.length === domain.length ? domain : newDomain;\n};\n\nconst getArgument: GetItemFn = point => point.argument;\nconst getValue: GetItemFn = point => point.value;\n\nconst guessFactory = (points: PointList, getItem: GetItemFn) => (\n points.length && typeof getItem(points[0]) === 'string' ? scaleBand : scaleLinear\n);\n\nconst isDiscrete = (factory: FactoryFn) => 'bandwidth' in factory();\n\nconst updateDomainFactory = (domain: DomainInfo, series: Series, getItem: GetItemFn) => {\n if (domain.factory) {\n return domain;\n }\n const factory = guessFactory(series.points, getItem);\n return {\n ...domain,\n factory,\n isDiscrete: isDiscrete(factory),\n };\n};\n\n/** @internal */\nexport const updateDomainItems = (domain: DomainInfo, items: DomainItems): DomainInfo => {\n const merge = domain.isDiscrete ? mergeDiscreteDomains : mergeContinuousDomains;\n const merged = merge(domain.domain, items);\n return merged === domain.domain ? domain : {\n ...domain,\n domain: domain.modifyDomain ? domain.modifyDomain(merged) : merged,\n };\n};\n\nconst getArgumentDomainItems: GetDomainItemsFn = series => series.points.map(getArgument);\n\nconst getValueDomainItems: GetDomainItemsFn = (series) => {\n const items = series.points.map(getValue);\n return series.getPointTransformer.isStartedFromZero ? [0, ...items] : items;\n};\n\nconst updateDomain = (\n domain: DomainInfo, series: Series, getItem: GetItemFn, getDomainItems: GetDomainItemsFn,\n) => updateDomainItems(updateDomainFactory(domain, series, getItem), getDomainItems(series));\n\n/** @internal */\nexport const extendDomains: ExtendDomainsFn = (domains, series) => {\n const argumentDomain = updateDomain(\n domains[ARGUMENT_DOMAIN], series, getArgument, getArgumentDomainItems);\n const valueDomainName = getValueDomainName(series.scaleName);\n const valueDomain = updateDomain(\n domains[valueDomainName], series, getValue, getValueDomainItems);\n const changes = {};\n if (argumentDomain !== domains[ARGUMENT_DOMAIN]) {\n changes[ARGUMENT_DOMAIN] = argumentDomain;\n }\n if (valueDomain !== domains[valueDomainName]) {\n changes[valueDomainName] = valueDomain;\n }\n return Object.keys(changes).length ? { ...domains, ...changes } : domains;\n};\n\n/** @internal */\nexport const buildScales: BuildScalesFn = (domains, ranges) => {\n const scales = {};\n Object.keys(domains).forEach((name) => {\n scales[name] = makeScale(\n domains[name],\n ranges[name === ARGUMENT_DOMAIN ? ARGUMENT_DOMAIN : VALUE_DOMAIN] as NumberArray,\n );\n });\n return scales;\n};\n","import { Size } from '@devexpress/dx-react-core';\nimport {\n ARGUMENT_DOMAIN, VALUE_DOMAIN,\n} from '../../constants';\nimport {\n BBoxes, BBoxesChange, RangesCache, NumberArray,\n} from '../../types';\n\nconst isEqual = (\n { width: firstWidth, height: firstHeight }: Size,\n { width: secondWidth, height: secondHeight }: Size,\n) => firstWidth === secondWidth && firstHeight === secondHeight;\n\n/** @internal */\nexport const bBoxes = (prevBBoxes: BBoxes, { bBox, placeholder }: BBoxesChange) => {\n if (isEqual(prevBBoxes[placeholder] || {}, bBox)) return prevBBoxes;\n return { ...prevBBoxes, [placeholder]: bBox };\n};\n\n/** @internal */\nexport const getRanges = (paneSize: Size, rotated: boolean): RangesCache => {\n const horRange: NumberArray = [0, paneSize.width];\n const verRange: NumberArray = [paneSize.height, 0];\n return {\n [ARGUMENT_DOMAIN]: rotated ? verRange : horRange,\n [VALUE_DOMAIN]: rotated ? horRange : verRange,\n };\n};\n","import { isHorizontal } from '../../utils/scale';\nimport {\n LEFT, RIGHT, TOP, BOTTOM, MIDDLE, END, START,\n} from '../../constants';\nimport {\n ScaleObject, GetFormatFn, ProcessTickFn, TickFormatFn, NumberArray, GetTickCoordinatesFn,\n TickCoordinatesGetterFn, Tick, Grid,\n} from '../../types';\n\nconst getTicks = (scale: ScaleObject, count: number) => (\n scale.ticks ? scale.ticks(count) : scale.domain()\n);\n\nconst createTicks = (\n scale: ScaleObject, count: number, callback: ProcessTickFn,\n): ReadonlyArray => (\n getTicks(scale, count)\n .map((tick, index) => callback(scale(tick), String(index), tick))\n);\n\nconst getFormat = (scale: ScaleObject, count: number, tickFormat?: TickFormatFn): GetFormatFn => {\n if (scale.tickFormat) {\n return tickFormat ? tickFormat(scale, count) : scale.tickFormat(count);\n }\n return tick => tick;\n};\n\nconst rotatedPositions = {\n [LEFT]: BOTTOM,\n [RIGHT]: TOP,\n [BOTTOM]: LEFT,\n [TOP]: RIGHT,\n};\n\nconst positionFlags = {\n [LEFT]: false,\n [RIGHT]: false,\n [BOTTOM]: true,\n [TOP]: true,\n};\n\n/** @internal */\nexport const getRotatedPosition = (position: string) => rotatedPositions[position];\n\n/** @internal */\nexport const isValidPosition = (position: string, scaleName: string, rotated: boolean) =>\n positionFlags[position] === isHorizontal(scaleName, rotated);\n\nconst createHorizontalOptions = (position: string, tickSize: number, indentFromAxis: number) => {\n // Make *position* orientation agnostic - should be START or END.\n const isStart = position === BOTTOM;\n return {\n y1: 0,\n y2: isStart ? +tickSize : -tickSize,\n yText: isStart ? +indentFromAxis : -indentFromAxis,\n dy: isStart ? '1em' : '0em',\n textAnchor: MIDDLE,\n };\n};\n\nconst createVerticalOptions = (position: string, tickSize: number, indentFromAxis: number) => {\n // Make *position* orientation agnostic - should be START or END.\n const isStart = position === LEFT;\n return {\n x1: 0,\n x2: isStart ? -tickSize : +tickSize,\n xText: isStart ? -indentFromAxis : +indentFromAxis,\n dy: '0.3em',\n textAnchor: isStart ? END : START,\n };\n};\n\n// Constant is selected to preserve original behavior described in\n// https://github.com/d3/d3-scale#continuous_ticks.\nconst DEFAULT_TICK_COUNT = 10;\nconst getTickCount = (scaleRange: NumberArray, paneSize: number) => {\n const rangeToPaneRatio = Math.abs(scaleRange[0] - scaleRange[1]) / paneSize;\n return Math.round(DEFAULT_TICK_COUNT * (isFinite(rangeToPaneRatio) ? rangeToPaneRatio : 1));\n};\n\nconst createTickFilter = (isHor: boolean, size: number) => (\n isHor\n ? (tick: any) => tick.x1 >= 0 && tick.x1 <= size\n : (tick: any) => tick.y1 >= 0 && tick.y1 <= size\n);\n\n/** @internal */\nexport const tickCoordinatesGetter: TickCoordinatesGetterFn = ({\n isHor, scale, tickCount, tickFormat, position, tickSize, indentFromAxis,\n}) => {\n const formatTick = getFormat(scale!, tickCount!, tickFormat);\n const options = (isHor ? createHorizontalOptions : createVerticalOptions)(\n position!, tickSize!, indentFromAxis!,\n );\n return (coordinates, key, tick) => ({\n key,\n x1: coordinates,\n x2: coordinates,\n y1: coordinates,\n y2: coordinates,\n xText: coordinates,\n yText: coordinates,\n text: formatTick(tick),\n ...options,\n });\n};\n\n/** @internal */\nexport const gridCoordinatesGetter: TickCoordinatesGetterFn = ({ isHor }) => {\n const options = isHor ? { y1: 0 } : { x1: 0 };\n return (coordinates, key) => ({\n key,\n x1: coordinates,\n y1: coordinates,\n ...options,\n });\n};\n\n/** @internal */\nexport const getTickCoordinates: GetTickCoordinatesFn = ({\n scaleName, scale, paneSize, rotated, callback, ...restProps\n}) => {\n const isHor = isHorizontal(scaleName, rotated);\n const tickCount = getTickCount(scale.range(), paneSize[1 - Number(isHor)]);\n const ticks = createTicks(scale, tickCount, callback({ isHor, scale, tickCount, ...restProps }));\n const visibleTicks = ticks.filter(createTickFilter(isHor, paneSize[1 - Number(isHor)]));\n return {\n ticks: visibleTicks,\n sides: [Number(isHor), Number(!isHor)],\n };\n};\n","import {\n symbol,\n symbolCircle,\n line,\n curveMonotoneX,\n curveMonotoneY,\n area,\n arc,\n pie,\n} from 'd3-shape';\nimport {\n SeriesList, Series, PointList, Point, DataItems, AddSeriesFn, ScalesCache, ScaleSeriesPointsFn,\n GetPointTransformerFn, Colors, Rect,\n BarSeries, ScatterSeries, PieSeries,\n PointComponentProps, PathFn, PathStartCoordinates, PathEndCoordinates, Scales,\n} from '../../types';\nimport { Size } from '@devexpress/dx-react-core';\nimport { ARGUMENT_DOMAIN } from '../../constants';\nimport { getValueDomainName, getWidth, rangesEqual } from '../../utils/scale';\n\nconst getArg = ({ arg }: PointComponentProps) => arg;\nconst getVal = ({ val }: PointComponentProps) => val;\nconst getStartVal = ({ startVal }: PointComponentProps) => startVal!;\n\n/** @internal */\nexport const dArea: PathFn = area()\n .x(getArg)\n .y1(getVal)\n .y0(getStartVal) as any;\n\n/** @internal */\nexport const dRotateArea: PathFn = area()\n .x1(getStartVal)\n .x0(getVal)\n .y(getArg) as any;\n\n/** @internal */\nexport const dLine: PathFn = line()\n .x(getArg)\n .y(getVal) as any;\n\n/** @internal */\nexport const dRotateLine = line()\n .x(getVal)\n .y(getArg) as any;\n\n/** @internal */\nexport const dSpline: PathFn = line()\n .x(getArg)\n .y(getVal)\n .curve(curveMonotoneX) as any;\n\n/** @internal */\nexport const dRotateSpline: PathFn = line()\n .x(getVal)\n .y(getArg)\n .curve(curveMonotoneY) as any;\n\n/** @internal */\nexport const dBar = (\n arg: number, val: number, startVal: number, width: number, rotated: boolean,\n) => {\n const height = Math.abs(val - startVal!);\n const minVal = Math.min(val, startVal!);\n return {\n x: rotated ? minVal : arg - width / 2,\n y: rotated ? arg - width / 2 : minVal,\n width: rotated ? height : width || 2,\n height: rotated ? width || 2 : height,\n };\n};\n\n/** @internal */\nexport const getPiePointTransformer: GetPointTransformerFn = ({\n argumentScale, valueScale, points,\n}) => {\n const x = Math.max(...argumentScale.range()) / 2;\n const y = Math.max(...valueScale.range()) / 2;\n const maxRadius = Math.min(x, y);\n const pieData = pie().sort(null).value(d => d.value)(points as Point[]);\n return (point) => {\n const { startAngle, endAngle } = pieData[point.index];\n return {\n ...point,\n arg: x,\n val: y,\n startAngle,\n endAngle,\n maxRadius,\n };\n };\n};\n\n/** @internal */\nexport const getLinePointTransformer: GetPointTransformerFn = ({\n argumentScale, valueScale,\n}) => point => ({\n ...point,\n arg: argumentScale(point.argument),\n val: valueScale(point.value),\n} as any);\n\n// Though transformations for line and scatter are the same,\n// separate function instance is required as it contains additional static fields.\n/** @internal */\nexport const getScatterPointTransformer: GetPointTransformerFn = (\n ...args\n) => getLinePointTransformer(...args);\n\n/** @internal */\nexport const getAreaPointTransformer: GetPointTransformerFn = (series) => {\n const transform = getLinePointTransformer(series);\n const startVal = series.valueScale(0);\n return (point) => {\n const ret = transform(point);\n return {\n ...ret,\n startVal,\n };\n };\n};\n// Used for domain calculation and stacking.\ngetAreaPointTransformer.isStartedFromZero = true;\n\n/** @internal */\nexport const getBarPointTransformer: GetPointTransformerFn = ({\n argumentScale, valueScale,\n}) => {\n const startVal = valueScale(0);\n return point => ({\n ...point,\n arg: argumentScale(point.argument),\n val: valueScale(point.value),\n startVal,\n maxBarWidth: getWidth(argumentScale),\n } as any);\n};\n// Used for domain calculation and stacking.\ngetBarPointTransformer.isStartedFromZero = true;\n// Used for Bar grouping.\ngetBarPointTransformer.isBroad = true;\n\ngetPiePointTransformer.getPointColor = (palette, index) => palette[index % palette.length];\n\n/** @internal */\nexport const findSeriesByName = (\n name: symbol, series: SeriesList,\n): Series => series.find(seriesItem => seriesItem.symbolName === name) as Series;\n\n/** @internal */\nexport const dSymbol = (\n { size }: ScatterSeries.PointOptions,\n) => symbol().size(size ** 2).type(symbolCircle)()!;\n\n/** @internal */\nexport const dPie = (\n maxRadius: number, innerRadius: number, outerRadius: number, startAngle: number, endAngle: number,\n) => arc()({\n startAngle,\n endAngle,\n innerRadius: innerRadius * maxRadius,\n outerRadius: outerRadius * maxRadius,\n})!;\n\nconst getRect = (\n cArg: number, cVal: number, dArg: number, dVal: number, rotated: boolean,\n): Rect => {\n const minArg = cArg - dArg;\n const minVal = cVal - dVal;\n const maxArg = cArg + dArg;\n const maxVal = cVal + dVal;\n return rotated ? [minVal, minArg, maxVal, maxArg] : [minArg, minVal, maxArg, maxVal];\n};\n\ngetBarPointTransformer.getTargetElement = (point) => {\n const {\n arg, val, startVal, barWidth, maxBarWidth, rotated,\n } = point as BarSeries.PointProps;\n const halfWidth = barWidth * maxBarWidth / 2;\n const halfHeight = Math.abs(startVal! - val) / 2;\n const centerVal = (val + startVal!) / 2;\n return getRect(arg, centerVal, halfWidth, halfHeight, rotated);\n};\n\ngetPiePointTransformer.getTargetElement = (point) => {\n const {\n arg: x, val: y, innerRadius, outerRadius, maxRadius, startAngle, endAngle,\n } = point as PieSeries.PointProps;\n const center = arc().centroid({\n startAngle,\n endAngle,\n innerRadius: innerRadius * maxRadius,\n outerRadius: outerRadius * maxRadius,\n });\n const cx = center[0] + x;\n const cy = center[1] + y;\n return getRect(cx, cy, 0.5, 0.5, false);\n};\n\ngetAreaPointTransformer.getTargetElement = ({ arg, val, rotated }) => (\n getRect(arg, val, 1, 1, rotated)\n);\n\ngetLinePointTransformer.getTargetElement = getAreaPointTransformer.getTargetElement;\n\ngetScatterPointTransformer.getTargetElement = (obj) => {\n const { arg, val, point, rotated } = obj as ScatterSeries.PointProps;\n const t = point.size / 2;\n return getRect(arg, val, t, t, rotated);\n};\n\nconst getUniqueName = (list: SeriesList, name: string) => {\n const names = new Set(list.map(item => item.name));\n let ret = name;\n while (names.has(ret)) {\n // @ts-ignore\n ret = ret.replace(/\\d*$/, str => (str ? +str + 1 : 0));\n }\n return ret;\n};\n\n// TODO: Memoization is much needed here.\n// Though \"series\" list never persists, single \"series\" item most often does.\nconst createPoints = (\n {\n argumentField, valueField, getPointTransformer,\n }: Series,\n data: DataItems, props: any, palette: Colors,\n): PointList => {\n const points: Point[] = [];\n data.forEach((dataItem, index) => {\n const argument = dataItem[argumentField];\n const value = dataItem[valueField];\n if (argument !== undefined && value !== undefined) {\n points.push({\n argument,\n value,\n index,\n ...props,\n color: getPointTransformer.getPointColor\n ? getPointTransformer.getPointColor(palette, index) : props.color,\n });\n }\n });\n return points;\n};\n\n/** @internal */\nexport const addSeries: AddSeriesFn = (\n series, data, palette, props, restProps,\n) => {\n // It is used to generate unique series dependent attribute names for patterns.\n // *symbolName* cannot be used as it cannot be part of DOM attribute name.\n const index = series.length;\n const seriesColor = props.color || palette[index % palette.length];\n return [...series, {\n ...props,\n index,\n name: getUniqueName(series, props.name),\n points: createPoints(props, data, { ...restProps, color: seriesColor }, palette),\n color: seriesColor,\n }];\n};\n\n// TODO: Memoization is much needed here by the same reason as in \"createPoints\".\n// Make \"scales\" persistent first.\nconst scalePoints = (series: Series, scales: ScalesCache, rotated: boolean) => {\n const transform = series.getPointTransformer({\n ...series,\n argumentScale: scales[ARGUMENT_DOMAIN],\n valueScale: scales[getValueDomainName(series.scaleName)],\n });\n const ret: Series = {\n ...series,\n rotated,\n points: series.points.map(point => ({\n ...transform(point),\n rotated,\n })),\n };\n return ret;\n};\n\n/** @internal */\nexport const scaleSeriesPoints: ScaleSeriesPointsFn = (\n series, scales, rotated,\n) => series.map(seriesItem => scalePoints(seriesItem, scales, rotated));\n\n/** @internal */\nexport const getVisibility = (\n pane: Size, centerX: number, centerY: number, width: number, height: number,\n) => {\n return (centerX - width / 2 < 0 && centerX + width / 2 < 0)\n || (centerX - width / 2 > pane.width && centerX + width / 2 > pane.width)\n || (centerY - height / 2 < 0 && centerY + height / 2 < 0)\n || (centerY - height / 2 > pane.height && centerY + height / 2 > pane.height) ?\n 'hidden' : 'visible';\n};\n\n/** @internal */\nexport const adjustBarSize = (\n bar: { width: number, height: number, x: number, y: number }, { width, height }: Size,\n) => {\n const x = Math.max(0, bar.x);\n const y = Math.max(0, bar.y);\n return {\n x,\n y,\n width: Math.min(width, bar.x + bar.width) - x,\n height: Math.min(height, bar.y + bar.height) - y,\n };\n};\n\n/** @internal */\nexport const isValuesChanged = (previous: any, current: any): boolean => {\n return Object.entries(previous).some(el => el[1] !== current[el[0]]);\n};\n\n/** @internal */\nexport const isCoordinatesChanged = (\n { coordinates: prevCoordinates }: PathStartCoordinates, { coordinates }: PathEndCoordinates,\n) => {\n if (prevCoordinates.length !== coordinates.length) {\n return true;\n }\n return prevCoordinates.some((el, index) => {\n return el.arg !== coordinates[index].arg || el.val !== coordinates[index].val;\n });\n};\n\n/** @internal */\nexport const isScalesChanged = (previous: Scales, current: Scales): boolean => {\n return !rangesEqual(previous.argScale.range(), current.argScale.range()) ||\n !rangesEqual(previous.valScale.range(), current.valScale.range());\n};\n","import { stack } from 'd3-shape';\nimport { scaleBand } from 'd3-scale';\nimport {\n SeriesList, Series, Point, GetPointTransformerFn, DataItems, DomainInfoCache,\n StackList, GetPointTransformerFnRaw, BarSeries, StackedPoint, StackMap, GetStackedSeriesFn,\n SeriesPositions, StacksKeys, StackedDataItems, OffsetFn, OrderFn,\n StackedData, GetStackedDomainsFn,\n} from '../../types';\nimport { extendDomains, updateDomainItems } from '../scale/computeds';\nimport { getValueDomainName } from '../../utils/scale';\n\n// \"Stack\" plugin relies on \"data\" and \"series\" getters and\n// knowledge about \"getPointTransformer\" and \"path\" functions behavior.\nconst buildSeriesToStackMap = (stacks: StackList): StackMap => {\n const result = {};\n stacks.forEach(({ series }, i) => {\n series.forEach((name) => {\n result[name] = i;\n });\n });\n return result;\n};\n\nconst getStackedPointTransformer = (getPointTransformer: GetPointTransformerFn) => {\n const wrapper: GetPointTransformerFnRaw = (series) => {\n const transform = getPointTransformer(series);\n const { valueScale } = series;\n return (point: Point) => {\n const ret = transform(point);\n return {\n ...ret,\n startVal: valueScale((point as StackedPoint).value0),\n };\n };\n };\n // Preserve static fields of original transformer.\n Object.assign(wrapper, getPointTransformer);\n return wrapper as GetPointTransformerFn;\n};\n\nconst collectStacks = (\n seriesList: SeriesList, seriesToStackMap: StackMap,\n stacksKeys: StacksKeys, seriesPositions: SeriesPositions,\n) => {\n seriesList.forEach(({ name, valueField }) => {\n const stackId = seriesToStackMap[name];\n if (stackId === undefined) {\n return;\n }\n\n if (!stacksKeys[stackId]) {\n stacksKeys[stackId] = [];\n }\n seriesPositions[name] = stacksKeys[stackId].length;\n stacksKeys[stackId].push(valueField);\n });\n // Stack cannot consist of single series.\n Object.keys(stacksKeys).forEach((stackId) => {\n if (stacksKeys[stackId].length === 1) {\n delete stacksKeys[stackId];\n }\n });\n};\n\nconst getStackedData = (\n stacksKeys: StacksKeys, dataItems: DataItems, offset: OffsetFn, order: OrderFn,\n): StackedData => {\n const result = {};\n Object.keys(stacksKeys).forEach((stackId) => {\n result[stackId] = stack().keys(stacksKeys[stackId])\n .order(order as any)\n .offset(offset as any)(dataItems as any);\n });\n return result;\n};\n\nconst buildStackedSeries = (series: Series, dataItems: StackedDataItems): Series => {\n const points = series.points.map((point) => {\n const [value0, value] = dataItems[point.index];\n return { ...point, value, value0 };\n });\n const stackedSeries = {\n ...series,\n points,\n isStacked: true,\n };\n if (series.getPointTransformer.isStartedFromZero) {\n stackedSeries.getPointTransformer = getStackedPointTransformer(series.getPointTransformer);\n }\n return stackedSeries;\n};\n\nconst applyStacking = (\n seriesList: SeriesList, dataItems: DataItems, seriesToStackMap: StackMap,\n offset: OffsetFn, order: OrderFn,\n): SeriesList => {\n const stacksKeys: StacksKeys = {};\n const seriesPositions: SeriesPositions = {};\n collectStacks(seriesList, seriesToStackMap, stacksKeys, seriesPositions);\n if (Object.keys(stacksKeys).length === 0) {\n return seriesList;\n }\n const stackedData = getStackedData(stacksKeys, dataItems, offset, order);\n return seriesList.map((seriesItem) => {\n const stackId = seriesToStackMap[seriesItem.name];\n const stackData = stackedData[stackId];\n if (!stackData) {\n return seriesItem;\n }\n const position = seriesPositions[seriesItem.name];\n return buildStackedSeries(seriesItem, stackData[position]);\n });\n};\n\nconst getGroupName = (series: Series, i: number, seriesToStackMap: StackMap) => {\n const stackId = seriesToStackMap[series.name];\n return stackId >= 0 ? String(stackId) : `group-${i}`;\n};\n\nconst getGroupedPointTransformer = (\n getPointTransformer: GetPointTransformerFn, groupCount: number, groupOffset: number,\n) => {\n const wrapper: GetPointTransformerFnRaw = (series) => {\n const transform = getPointTransformer(series);\n const widthCoeff = 1 / groupCount;\n return (point) => {\n const original = transform(point) as BarSeries.PointProps;\n const arg = (\n original.arg - original.maxBarWidth * (0.5 - 0.5 * widthCoeff - groupOffset * widthCoeff)\n );\n const result: BarSeries.PointProps = {\n ...original,\n arg,\n maxBarWidth: original.maxBarWidth / groupCount,\n };\n return result;\n };\n };\n // Preserve static fields of original transformer.\n Object.assign(wrapper, getPointTransformer);\n return wrapper as GetPointTransformerFn;\n};\n\nconst applyGrouping = (seriesList: SeriesList, seriesToStackMap: StackMap): SeriesList => {\n const groups = new Set();\n seriesList.forEach((seriesItem, i) => {\n if (seriesItem.getPointTransformer.isBroad) {\n groups.add(getGroupName(seriesItem, i, seriesToStackMap));\n }\n });\n // There cannot be single group.\n if (groups.size < 2) {\n return seriesList;\n }\n const scale = scaleBand().domain(Array.from(groups)).range([0, groups.size]);\n return seriesList.map((seriesItem, i) => {\n if (!seriesItem.getPointTransformer.isBroad) {\n return seriesItem;\n }\n const getPointTransformer = getGroupedPointTransformer(\n seriesItem.getPointTransformer,\n groups.size,\n scale(getGroupName(seriesItem, i, seriesToStackMap))!,\n );\n return {\n ...seriesItem,\n getPointTransformer,\n };\n });\n};\n\n/** @internal */\nexport const getStackedSeries: GetStackedSeriesFn = (\n seriesList, dataItems, { stacks, offset, order },\n) => {\n const map = buildSeriesToStackMap(stacks);\n const stackedSeriesList = applyStacking(seriesList, dataItems, map, offset, order);\n const groupedSeriesList = applyGrouping(stackedSeriesList, map);\n return groupedSeriesList;\n};\n\nconst resetDomainItems = (domains: DomainInfoCache): DomainInfoCache => {\n const result = {};\n Object.keys(domains).forEach((key) => {\n result[key] = { ...domains[key], domain: [] };\n });\n return result;\n};\n\nconst extendDomainsWithAdditionalItems = (domains: DomainInfoCache, series: Series) => {\n const items = series.points.map(point => (point as StackedPoint).value0);\n const key = getValueDomainName(series.scaleName);\n const domain = updateDomainItems(domains[key], items);\n return domain !== domains[key] ? { ...domains, [key]: domain } : domains;\n};\n\n// Stacking changes data - so computed domains have to be discarded\n// and recalculated from the new stacked data.\n/** @internal */\nexport const getStackedDomains: GetStackedDomainsFn = (domains, seriesList) => {\n const stackedSeries = seriesList.filter(series => (series as any).isStacked);\n if (!stackedSeries.length) {\n return domains;\n }\n // Recalculate domains in a common way.\n const rebuiltDomains = seriesList.reduce(extendDomains, resetDomainItems(domains));\n // Take additional \"value0\" fields into account.\n return stackedSeries.reduce(extendDomainsWithAdditionalItems, rebuiltDomains);\n};\n","import {\n Scales, PointComponentProps, PieSeries, PathComponentProps, GetDelayFn,\n} from '../../types';\n\n/** @internal */\nexport const easeOutCubic = (t: number) => (t - 1) * (t - 1) * (t - 1) + 1;\n\n/** @internal */\nexport const getDelay: GetDelayFn = (index, isStart) => isStart ? index * 30 : 0;\n\n/** @internal */\nexport const getStartVal = (scales: Scales) => {\n return scales.valScale.copy().clamp!(true)(0);\n};\n\n/** @internal */\nexport const getPathStart = (scales: Scales, { coordinates }: PathComponentProps) => {\n const start = getStartVal(scales);\n return { coordinates: coordinates.map(coord =>\n ({ arg: coord.arg, val: start, startVal: start })) };\n};\n\n/** @internal */\nexport const getPointStart = (scales: Scales, { arg }: PointComponentProps) => {\n const start = getStartVal(scales);\n return { arg, val: start, startVal: start };\n};\n\n/** @internal */\nexport const getPieStart = (scales: Scales, { startAngle, endAngle }: PieSeries.PointProps) =>\n({ innerRadius: 0, outerRadius: 0, startAngle, endAngle });\n","import { SeriesRef, TargetList, NotifyPointerMoveFn, ProcessedTarget } from '../types';\n\n// Comparing by reference is not an option as Tracker always sends new objects.\n// Tracker cannot persist references as it actually operates with simple scalars\n// and constructs objects to provide info in a slightly more suitable way.\nconst compareTargets = (target1: SeriesRef, target2: SeriesRef) => (\n target1.series === target2.series && target1.point === target2.point\n);\n\n// If *currentTarget* is among *targets* then it has priority but only while its distance\n// is not significantly greater (DISTANCE_PRIORITY_RATIO) than that of the best candidate.\nconst selectTarget = (targets: TargetList, currentTarget: SeriesRef): ProcessedTarget => {\n const candidate = targets[0];\n if (!currentTarget) {\n return candidate;\n }\n if (!candidate) {\n return null;\n }\n return compareTargets(candidate, currentTarget) ? undefined : candidate;\n};\n\n/** @internal */\nexport const processPointerMove = (\n targets: TargetList, currentTarget: SeriesRef, notify?: NotifyPointerMoveFn,\n) => {\n const nextTarget = selectTarget(targets, currentTarget);\n if (nextTarget === undefined) {\n return undefined;\n }\n if (notify) {\n notify(nextTarget);\n }\n return nextTarget;\n};\n","import { NumberArray, Location } from '../types';\n// This function is to be called from context where DOM is available -\n// so *window* can be accessed safely.\n/** @internal */\nexport const getOffset = (element: Element): NumberArray => {\n const { left, top } = element.getBoundingClientRect();\n // Safer way to get window.\n const { defaultView } = element.ownerDocument!;\n const { pageXOffset, pageYOffset } = defaultView!;\n return [left + pageXOffset, top + pageYOffset];\n};\n\n/** @internal */\nexport const getEventCoords = (e: any, offset: NumberArray): Location => {\n const { pageX, pageY } = e.touches ? e.touches[0] : e;\n return [pageX - offset[0], pageY - offset[1]];\n};\n","import { processPointerMove } from '../../utils/hover-state';\nimport { getOffset } from '../../utils/common';\nimport {\n SeriesList, SeriesRef, TransformedPoint, TargetList, NotifyPointerMoveFn,\n TooltipParameters, TooltipReference, Rect,\n} from '../../types';\n\n/** @internal */\nexport const getParameters = (series: SeriesList, target: SeriesRef): TooltipParameters => {\n const currentSeries = series.find(({ name }) => target.series === name)!;\n const item = currentSeries.points.find(point => point.index === target.point) as TransformedPoint;\n return {\n element: currentSeries.getPointTransformer.getTargetElement(item),\n text: `${item.value}`,\n };\n};\n\n/** @internal */\nexport const createReference = (\n rect: Rect, rootRef: React.RefObject,\n): TooltipReference => ({\n // These two fields together with *width* and *height* are left with stub data for\n // simplicity reasons - they seem to be unused by *Popper*.\n clientWidth: 0,\n clientHeight: 0,\n getBoundingClientRect() {\n // This function is expected to be called (by the *Popper*) when DOM is ready -\n // so *rootRef.current* can be accessed.\n const offset = getOffset(rootRef.current!);\n // *getBoundingClientRect* of a real html element is affected by window scrolling.\n // *popper.js* subscribes \"html -> getBoundingClientRect -> (left, top)\" from\n // \"reference -> getBoundingClientRect\" - so here it is added.\n const htmlRect = rootRef.current!.ownerDocument!.documentElement.getBoundingClientRect();\n const left = rect[0] + offset[0] + htmlRect.left;\n const right = rect[2] + offset[0] + htmlRect.left;\n const top = rect[1] + offset[1] + htmlRect.top;\n const bottom = rect[3] + offset[1] + htmlRect.top;\n return {\n left,\n top,\n right,\n bottom,\n width: right - left,\n height: bottom - top,\n };\n },\n});\n\n/** @internal */\nexport const processHandleTooltip = (\n targets: TargetList, currentTarget: SeriesRef, onTargetItemChange?: NotifyPointerMoveFn,\n) => {\n const filterTargets = targets.filter(target => target.point !== undefined);\n return processPointerMove(filterTargets, currentTarget, onTargetItemChange);\n};\n","import {\n ARGUMENT_DOMAIN, VALUE_DOMAIN,\n} from '../../constants';\nimport {\n getValueDomainName, makeScale, scaleBounds, rangesEqual,\n moveBounds, growBounds, invertBoundsRange,\n} from '../../utils/scale';\nimport {\n NumberArray,\n Viewport,\n ScalesCache,\n DomainInfoCache,\n RangesCache,\n DomainInfo,\n DomainBounds,\n OnViewportChangeFn,\n ScaleObject,\n EventHandlers,\n Location,\n Interaction,\n} from '../../types';\nimport { Size } from '@devexpress/dx-react-core';\n\nconst getArgumentBounds = (viewport?: Viewport): DomainBounds | null => (\n viewport && viewport.argumentStart !== undefined && viewport.argumentEnd !== undefined\n ? [viewport.argumentStart, viewport.argumentEnd] : null\n);\n\nconst getValueBounds = (viewport?: Viewport): DomainBounds | null => (\n viewport && viewport.valueStart !== undefined && viewport.valueEnd !== undefined\n ? [viewport.valueStart, viewport.valueEnd] : null\n);\n\nconst getValueScaleName = (viewport?: Viewport) => (\n getValueDomainName(viewport && viewport.scaleName)\n);\n\nconst getDefaultBounds = (scale: ScaleObject): DomainBounds => {\n const domain = scale.domain();\n return [domain[0], domain[domain.length - 1]];\n};\n\nconst proportionallyExtendRange = (range: NumberArray, subRange: NumberArray): NumberArray => {\n const p = (subRange[0] - subRange[1]) / (range[0] - range[1]);\n const q = subRange[0] - p * range[0];\n return [\n (range[0] - q) / p,\n (range[1] - q) / p,\n ];\n};\n\nconst adjustRange = (domain: DomainInfo, bounds: DomainBounds, range: NumberArray) => {\n const scale = makeScale(domain, range);\n const subRange = scaleBounds(scale, bounds);\n return rangesEqual(subRange, range) ? range : proportionallyExtendRange(range, subRange);\n};\n\nconst update = (\n ranges: RangesCache, changes: any, key: string, domain: DomainInfo, bounds: DomainBounds,\n) => {\n const newRange = adjustRange(domain, bounds, ranges[key]);\n if (newRange !== ranges[key]) {\n changes[key] = newRange;\n }\n};\n\n/** @internal */\nexport const adjustLayout = (\n domains: DomainInfoCache, ranges: RangesCache, viewport?: Viewport,\n) => {\n const changes = {};\n const argumentBounds = getArgumentBounds(viewport);\n if (argumentBounds) {\n update(ranges, changes, ARGUMENT_DOMAIN, domains[ARGUMENT_DOMAIN], argumentBounds);\n }\n const valueBounds = getValueBounds(viewport);\n if (valueBounds) {\n update(ranges, changes, VALUE_DOMAIN, domains[getValueScaleName(viewport)], valueBounds);\n }\n return Object.keys(changes).length ? { ...ranges, ...changes } : ranges;\n};\n\nconst boundsForScale = (\n name: string, scales: ScalesCache, currentBounds: DomainBounds | null,\n interaction: Interaction, type: Interaction, delta: number, anchor: number, range?: NumberArray,\n): DomainBounds | null => {\n if (!checkInteraction(interaction, type)) {\n return null;\n }\n const scale = scales[name];\n const bounds = currentBounds || getDefaultBounds(scale);\n let newBounds: DomainBounds;\n if (type === 'pan') {\n newBounds = moveBounds(scale, bounds, delta);\n } else if (type === 'zoom') {\n newBounds = range ? invertBoundsRange(scale, range) : growBounds(scale, bounds, delta, anchor);\n }\n return newBounds! !== bounds ? newBounds! : null;\n};\n\n/** @internal */\nexport const getViewport = (\n scales: ScalesCache,\n rotated: boolean,\n [argInteraction, valInteraction]: Readonly<[Interaction, Interaction]>, type: Interaction,\n deltas: Readonly<[number, number]> | null,\n anchors: Readonly | null,\n ranges: Readonly<[NumberArray, NumberArray]> | null,\n viewport?: Viewport, onViewportChange?: OnViewportChangeFn,\n) => {\n const argIndex = Number(rotated);\n const valIndex = 1 - argIndex;\n const changes: any = {};\n const argumentBounds = boundsForScale(\n ARGUMENT_DOMAIN, scales, getArgumentBounds(viewport),\n argInteraction, type,\n deltas ? deltas[argIndex] : 0, anchors ? anchors[argIndex] : 0,\n ranges ? ranges[argIndex] : undefined,\n );\n const valueBounds = boundsForScale(\n getValueScaleName(viewport), scales, getValueBounds(viewport),\n valInteraction, type,\n deltas ? deltas[valIndex] : 0, anchors ? anchors[valIndex] : 0,\n ranges ? ranges[valIndex] : undefined,\n );\n if (argumentBounds) {\n changes.argumentStart = argumentBounds[0];\n changes.argumentEnd = argumentBounds[1];\n }\n if (valueBounds) {\n changes.valueStart = valueBounds[0];\n changes.valueEnd = valueBounds[1];\n }\n if (Object.keys(changes).length) {\n const newViewport = { ...viewport, ...changes };\n if (onViewportChange) {\n onViewportChange(newViewport);\n }\n return { viewport: newViewport };\n }\n return null;\n};\n\n/** @internal */\nexport const getDeltaForTouches = (touches: Touch[]) => {\n const deltaX = touches[0].pageX - touches[1].pageX;\n const deltaY = touches[0].pageY - touches[1].pageY;\n const delta = Math.sqrt(deltaX * deltaX + deltaY * deltaY);\n const center: NumberArray = [\n (touches[0].pageX + touches[1].pageX) / 2,\n (touches[0].pageY + touches[1].pageY) / 2,\n ];\n return { delta, center };\n};\n\n/** @internal */\nexport const isKeyPressed = (event: MouseEvent, key: string) => event[`${key}Key`];\n\n/** @internal */\nexport const getWheelDelta = ({ wheelDelta, deltaY }: { wheelDelta?: number, deltaY?: number }) => {\n return wheelDelta !== undefined ? wheelDelta : deltaY! * -30; // deltaY for FF\n};\n\n/** @internal */\nexport const isMultiTouch = (e: any) => e.touches && e.touches.length === 2;\n\n/** @internal */\nexport const attachEvents = (node: any, handlers: EventHandlers) => {\n Object.keys(handlers).forEach((el) => {\n node.addEventListener(el, handlers[el], { passive: false });\n });\n};\n\n/** @internal */\nexport const detachEvents = (node: any, handlers: EventHandlers) => {\n Object.keys(handlers).forEach((el) => {\n node.removeEventListener(el, handlers[el]);\n });\n};\n\n/** @internal */\nexport const getRect = (\n rotated: boolean,\n interactionWithArguments: Interaction,\n interactionWithValues: Interaction,\n initial: Location,\n current: Location,\n pane: Size,\n) => {\n const isZoomArgument = checkInteraction(interactionWithArguments, 'zoom');\n const isZoomValue = checkInteraction(interactionWithValues, 'zoom');\n const isXFixed = rotated ? isZoomValue : isZoomArgument;\n const isYFixed = rotated ? isZoomArgument : isZoomValue;\n const x = isXFixed ? Math.min(initial[0], current[0]) : 0;\n const width = isXFixed ? Math.abs(initial[0] - current[0]) : pane.width;\n const y = isYFixed ? Math.min(initial[1], current[1]) : 0;\n const height = isYFixed ? Math.abs(initial[1] - current[1]) : pane.height;\n return {\n x, y, width, height,\n };\n};\n\nconst checkInteraction = (interaction: Interaction, type: Interaction) =>\ninteraction === 'both' || interaction === type;\n\n/** @internal */\nexport const setCursorType = (node: any, type?: string) => {\n const defaultType = 'pointer';\n node.style.cursor = type ? type : defaultType;\n};\n","import { DIFFERENCE } from '../../constants';\n\n/** @internal */\nexport const isReadyToRenderSeries = (\n { pane, ...restLayouts }, { current },\n isPreviousDataEmpty: boolean, axesExist: boolean,\n) => {\n if (!pane.width && !pane.height) {\n return false;\n }\n const bbox = { width: current.clientWidth, height: current.clientHeight };\n let width = pane.width;\n let height = pane.height;\n Object.entries(restLayouts).forEach((el) => {\n const orientation = el[0].split('-')[0];\n if (orientation === 'top' || orientation === 'bottom') {\n height += el[1].height;\n } else {\n width += el[1].width;\n }\n });\n return Math.abs(bbox.width - width) < DIFFERENCE &&\n Math.abs(bbox.height - height) < DIFFERENCE\n && isPreviousDataEmptyOrNoAxes(isPreviousDataEmpty, axesExist);\n};\n\nconst isPreviousDataEmptyOrNoAxes = (\n isPreviousDataEmpty: boolean, axesExist: boolean,\n) => !isPreviousDataEmpty || !axesExist;\n","import { area } from 'd3-shape';\nimport {\n dArea, dRotateArea, dLine, dRotateLine, dSpline, dRotateSpline,\n} from '../plugins/series/computeds';\nimport {\n SeriesList, TransformedPoint, PointList, TargetList, PointDistance, Location,\n CreateHitTesterFn, MakePathFn, IsPointInPathFn,\n HitTestPointFn, Filter,\n BarSeries, ScatterSeries, PieSeries,\n PathFn,\n} from '../types';\n\nconst getSegmentLength = (dx: number, dy: number) => Math.sqrt(dx * dx + dy * dy);\n\n// *distance* is a normalized distance to point.\n// It belongs to [0, Infinity):\n// = 0 - at point center\n// = 1 - at point border\n// > 1 - outside point\n\n// This function is called from event handlers (when DOM is available) -\n// *window.document* can be accessed safely.\nconst createContext = () => document.createElement('canvas').getContext('2d')!;\n\n// For a start using browser canvas will suffice.\n// However a better and more clean solution should be found.\n// Can't d3 perform hit testing?\nconst createCanvasAbusingHitTester = (\n makePath: MakePathFn, points: PointList, rotated: boolean,\n): IsPointInPathFn => {\n const ctx = createContext();\n const path = makePath(rotated);\n path.context(ctx);\n path(points as any);\n return ([x, y]) => ctx.isPointInPath(x, y);\n};\n\nconst LINE_POINT_SIZE = 20;\nconst LINE_TOLERANCE = 10;\n\nconst getDistance = (\n [px, py]: Location, { arg, val }: TransformedPoint, rotated: boolean,\n) => {\n const x = rotated ? val : arg;\n const y = rotated ? arg : val;\n return getSegmentLength(px - x, py - y);\n};\n\nconst createContinuousSeriesHitTesterCreator =\n (makePath: MakePathFn): CreateHitTesterFn => (points, rotated) => {\n const fallbackHitTest = createCanvasAbusingHitTester(makePath, points, rotated);\n return (target) => {\n let minDistance = Number.MAX_VALUE;\n let minIndex: number = 0;\n const list: PointDistance[] = [];\n points.forEach((point, i) => {\n const distance = getDistance(target, point as TransformedPoint, rotated);\n if (distance <= LINE_POINT_SIZE) {\n list.push({ distance, index: point.index });\n }\n if (distance < minDistance) {\n minDistance = distance;\n minIndex = i;\n }\n });\n // This is special case for continuous series - if no point is actually hit\n // then the closest point to the pointer position is picked.\n if (!list.length && fallbackHitTest(target)) {\n list.push({ index: points[minIndex].index, distance: minDistance });\n }\n return list.length ? { points: list } : null;\n };\n };\n\nconst createPointsEnumeratingHitTesterCreator =\n (hitTestPoint: HitTestPointFn): CreateHitTesterFn => (points, rotated) => (target) => {\n const list: PointDistance[] = [];\n points.forEach((point) => {\n const status = hitTestPoint(target, point as TransformedPoint, rotated);\n if (status) {\n list.push({ index: point.index, distance: status.distance });\n }\n });\n return list.length ? { points: list } : null;\n };\n\n/** @internal */\nexport const createAreaHitTester = createContinuousSeriesHitTesterCreator((rotated) => {\n const path: PathFn = area() as any;\n const hitArea = rotated ? dRotateArea : dArea;\n if (rotated) {\n path.x1!(hitArea.x1!());\n path.x0!(hitArea.x0!());\n path.y(hitArea.y());\n } else {\n path.x(hitArea.x());\n path.y1!(hitArea.y1!());\n path.y0!(hitArea.y0!());\n }\n return path;\n});\n\n/** @internal */\nexport const createLineHitTester = createContinuousSeriesHitTesterCreator((rotated) => {\n const path: PathFn = area() as any;\n const hitLine = rotated ? dRotateLine : dLine;\n if (rotated) {\n const getX = hitLine.x();\n path.y(hitLine.y());\n path.x0!(point => getX(point) + LINE_TOLERANCE);\n path.x1!(point => getX(point) - LINE_TOLERANCE);\n } else {\n const getY = hitLine.y();\n path.x(hitLine.x());\n path.y1!(point => getY(point) - LINE_TOLERANCE);\n path.y0!(point => getY(point) + LINE_TOLERANCE);\n }\n return path;\n});\n\n/** @internal */\nexport const createSplineHitTester = createContinuousSeriesHitTesterCreator((rotated) => {\n const path: PathFn = area() as any;\n const hitSpline = rotated ? dRotateSpline : dSpline;\n if (rotated) {\n const getX = hitSpline.x();\n path.y(hitSpline.y());\n path.x1!(point => getX(point) - LINE_TOLERANCE);\n path.x0!(point => getX(point) + LINE_TOLERANCE);\n } else {\n const getY = hitSpline.y();\n path.x(hitSpline.x());\n path.y1!(point => getY(point) - LINE_TOLERANCE);\n path.y0!(point => getY(point) + LINE_TOLERANCE);\n }\n path.curve!(hitSpline.curve!());\n return path;\n});\n\nconst hitTestRect = (dx: number, dy: number, halfX: number, halfY: number) => (\n Math.abs(dx) <= halfX && Math.abs(dy) <= halfY ? {\n distance: getSegmentLength(dx, dy),\n } : null\n);\n\n// Some kind of binary search can be used here as bars can be ordered along argument axis.\n/** @internal */\nexport const createBarHitTester = createPointsEnumeratingHitTesterCreator(\n ([px, py], point, rotated) => {\n const {\n arg, val, startVal, barWidth, maxBarWidth,\n } = point as BarSeries.PointProps;\n const halfWidth = maxBarWidth * barWidth / 2;\n const halfHeight = Math.abs(val - startVal!) / 2;\n const centerVal = (val + startVal!) / 2;\n const xCenter = rotated ? centerVal : arg;\n const yCenter = rotated ? arg : centerVal;\n return hitTestRect(\n px - xCenter,\n py - yCenter,\n rotated ? halfHeight : halfWidth,\n rotated ? halfWidth : halfHeight,\n );\n },\n);\n\n/** @internal */\nexport const createScatterHitTester = createPointsEnumeratingHitTesterCreator(\n ([px, py], obj, rotated) => {\n const { point } = obj as ScatterSeries.PointProps;\n const distance = getDistance([px, py], obj, rotated);\n return distance <= point.size / 2 ? { distance } : null;\n },\n);\n\nconst mapAngleTod3 = (angle: number) => {\n const ret = angle + Math.PI / 2;\n return ret >= 0 ? ret : ret + Math.PI * 2;\n};\n\n// Some kind of binary search can be used here as pies can be ordered along angle axis.\n/** @internal */\nexport const createPieHitTester = createPointsEnumeratingHitTesterCreator(\n ([px, py], point) => {\n const {\n arg: x, val: y, innerRadius, outerRadius, startAngle, maxRadius, endAngle,\n } = point as PieSeries.PointProps;\n const inner = innerRadius * maxRadius;\n const outer = outerRadius * maxRadius;\n const rCenter = (inner + outer) / 2;\n const angleCenter = (startAngle + endAngle) / 2;\n const halfRadius = (outer - inner) / 2;\n const halfAngle = Math.abs(startAngle - endAngle) / 2;\n const dx = px - x;\n const dy = py - y;\n const r = getSegmentLength(dx, dy);\n const angle = mapAngleTod3(Math.atan2(dy, dx));\n // This is not a correct distance calculation but for now it will suffice.\n // For Pie series it would not be actually used.\n return hitTestRect(r - rCenter, angle - angleCenter, halfRadius, halfAngle);\n },\n);\n\nconst buildFilter = (targets: TargetList): Filter => {\n const result = {};\n targets.forEach(({ series, point }) => {\n (result[series] = result[series] || new Set()).add(point);\n });\n return result;\n};\n\n/** @internal */\nexport const changeSeriesState = (seriesList: SeriesList, targets: TargetList, state: string) => {\n if (targets.length === 0) {\n return seriesList;\n }\n const filter = buildFilter(targets);\n let matches = 0;\n const result = seriesList.map((seriesItem) => {\n const set = filter[seriesItem.name];\n if (!set) {\n return seriesItem;\n }\n matches += 1;\n const props: { state: string, points?: TransformedPoint[] } = { state };\n if (set.size) {\n props.points = (seriesItem.points as TransformedPoint[]).map(\n point => (set.has(point.index) ? { ...point, state } : point),\n );\n }\n return { ...seriesItem, ...props };\n });\n // This is to prevent false rerenders.\n return matches > 0 ? result : seriesList;\n};\n","import { SeriesList, LegendItemList } from '../types';\n\nconst getDefaultLegendItems = (series: SeriesList): LegendItemList => series.map(\n ({ name: text, color }) => ({ text, color }),\n);\n\nconst getPieLegendItems = (series: SeriesList): LegendItemList => series[0]\n .points.map(({ argument: text, color }) => ({ text, color }));\n\n// The function supports special case when there is single Pie series.\n// There is no common way to tell if series is PieSeries -\n// checking `radius` props will suffice for now.\nconst isSinglePieSeriesCase = (series: SeriesList) => (\n series.length === 1 && 'innerRadius' in series[0] && 'outerRadius' in series[0]\n);\n\n/** @internal */\nexport const getLegendItems = (series: SeriesList) => (\n (isSinglePieSeriesCase(series) ? getPieLegendItems : getDefaultLegendItems)(series)\n);\n","import { hasWindow } from '@devexpress/dx-core';\nimport { getEventCoords, getOffset } from './common';\nimport {\n TrackerTarget, HandlerFnList, SeriesList, HitTesters,\n EventHandlerFn, TargetData, EventHandlers, HandlersObject,\n} from '../types';\n\nconst DISTANCE_THRESHOLD = 20;\n\nconst compareHitTargets = (t1: TrackerTarget, t2: TrackerTarget) => {\n const distanceDelta = t1.distance - t2.distance;\n if (Math.abs(distanceDelta) <= DISTANCE_THRESHOLD) {\n const orderDelta = t2.order - t1.order;\n return orderDelta !== 0 ? orderDelta : distanceDelta;\n }\n return distanceDelta;\n};\n\nconst buildEventHandler = (seriesList: SeriesList, handlers: HandlerFnList): EventHandlerFn => {\n let hitTesters: HitTesters | null = null;\n\n const createHitTesters = () => {\n const obj: HitTesters = {};\n seriesList.forEach((seriesItem) => {\n obj[seriesItem.symbolName as unknown as string] = seriesItem\n .createHitTester(seriesItem.points, seriesItem.rotated);\n });\n return obj;\n };\n\n return (e) => {\n const location = getEventCoords(e, getOffset(e.currentTarget));\n hitTesters = hitTesters || createHitTesters();\n const targets: TrackerTarget[] = [];\n seriesList.forEach(({ name: series, index: order, symbolName }) => {\n const status = hitTesters![symbolName as unknown as string](location);\n if (status) {\n targets.push(...status.points.map(\n point => ({\n series, order, point: point.index, distance: point.distance,\n }),\n ));\n }\n });\n targets.sort(compareHitTargets);\n const arg: TargetData = { location, targets, event: e.nativeEvent };\n handlers.forEach(handler => handler(arg));\n };\n};\n\nconst buildLeaveEventHandler = (handlers: HandlerFnList): EventHandlerFn => (e) => {\n const location = getEventCoords(e, getOffset(e.currentTarget));\n const arg: TargetData = { location, targets: [] };\n handlers.forEach(handler => handler(arg));\n};\n\n// The result is of Map type.\n// Keys are DOM event names (https://developer.mozilla.org/en-US/docs/Web/Events).\n/** @internal */\nexport const buildEventHandlers = (\n seriesList: SeriesList, { clickHandlers, pointerMoveHandlers }: HandlersObject,\n) => {\n const handlers: EventHandlers = {};\n if (!hasWindow()) return handlers;\n if (clickHandlers.length) {\n handlers.click = buildEventHandler(seriesList, clickHandlers);\n }\n if (pointerMoveHandlers.length) {\n const moveHandler = buildEventHandler(seriesList, pointerMoveHandlers);\n const leaveHandler = buildLeaveEventHandler(pointerMoveHandlers);\n if ('ontouchstart' in window) {\n handlers.touchstart = moveHandler;\n } else {\n handlers.mousemove = moveHandler;\n handlers.mouseleave = leaveHandler;\n }\n }\n return handlers;\n};\n","import {\n EasingFn, SetAttributeFn, AnimationFn, GetNewPositionsFn,\n RangePointCoordinates, PointCoordinates, PointComponentProps,\n PieCoordinates, PathStartCoordinates, PathEndCoordinates,\n} from '../types';\n\n/** @internal */\nconst getProgress = ({ elapsed, total }: {elapsed: number, total: number}) =>\nMath.min(elapsed / total, 1);\n\n/** @internal */\nconst runAnimation = (\n setAttributes: SetAttributeFn,\n getNewPositions: GetNewPositionsFn,\n easing: EasingFn, duration: number, delay: number,\n) => new Promise((resolve) => {\n setTimeout(() => {\n const time = {\n start: Date.now(),\n total: duration,\n elapsed: 0,\n };\n const step = () => {\n time.elapsed = Date.now() - time.start;\n const progress = getProgress(time);\n setAttributes(getNewPositions(easing(progress)));\n\n if (progress < 1) requestAnimationFrame(step);\n };\n resolve(requestAnimationFrame(step));\n }, delay);\n});\n\n/** @internal */\nexport const buildAnimation = (easing: EasingFn, duration: number): AnimationFn => (\n startCoords, endCoords, processAnimation, setAttributes, delay = 0,\n) => {\n let animationID;\n\n const stop = () => {\n if (animationID) {\n cancelAnimationFrame(animationID);\n animationID = undefined;\n }\n };\n\n const run = (start, end, delayValue) => {\n animationID = runAnimation(\n setAttributes, processAnimation(start, end),\n easing, duration, delayValue,\n ).then((res) => {\n animationID = res;\n });\n };\n\n run(startCoords, endCoords, delay);\n\n return {\n update: (updatedStartCoords, updatedEndCoords, updatedDelay = 0) => {\n stop();\n run(updatedStartCoords, updatedEndCoords, updatedDelay);\n },\n stop,\n };\n};\n\nconst lerp = (a: number, b: number, t: number) => a + t * (b - a);\n\n/** @internal */\nexport const processPointAnimation = (\n startCoords: PointCoordinates, endCoords: PointComponentProps,\n) => {\n return (progress: number) => {\n return {\n arg: lerp(startCoords.arg, endCoords.arg, progress),\n val: lerp(startCoords.val, endCoords.val, progress),\n };\n };\n};\n\n/** @internal */\nexport const processBarAnimation = (\n startCoords: RangePointCoordinates, endCoords: PointComponentProps,\n) => {\n return (progress: number) => {\n return {\n arg: lerp(startCoords.arg, endCoords.arg, progress),\n val: lerp(startCoords.val, endCoords.val, progress),\n startVal: lerp(startCoords.startVal, endCoords.startVal, progress),\n };\n };\n};\n\n/** @internal */\nexport const processLineAnimation = (\n { coordinates }: PathStartCoordinates,\n { coordinates: endCoordinates }: PathEndCoordinates,\n) => {\n return (progress: number) => {\n return {\n coordinates: endCoordinates.map((coord, index) => {\n const startCurCoord = coordinates[index];\n return {\n ...coord,\n arg: lerp(startCurCoord.arg, coord.arg, progress),\n val: lerp(startCurCoord.val, coord.val, progress),\n };\n }),\n };\n };\n};\n\n/** @internal */\nexport const processAreaAnimation = (\n { coordinates }: PathStartCoordinates,\n { coordinates: endCoordinates }: PathEndCoordinates,\n) => {\n return (progress: number) => {\n return {\n coordinates: endCoordinates.map((coord, index) => {\n const startCurCoord = coordinates[index];\n return {\n ...coord,\n arg: lerp(startCurCoord.arg, coord.arg, progress),\n val: lerp(startCurCoord.val, coord.val, progress),\n startVal: lerp(startCurCoord.startVal, coord.startVal, progress),\n };\n }),\n };\n };\n};\n\n/** @internal */\nexport const processPieAnimation = (start: PieCoordinates, end: PieCoordinates) => {\n return (progress: number) => {\n return {\n innerRadius: lerp(start.innerRadius, end.innerRadius, progress),\n outerRadius: lerp(start.outerRadius, end.outerRadius, progress),\n startAngle: lerp(start.startAngle, end.startAngle, progress),\n endAngle: lerp(start.endAngle, end.endAngle, progress),\n };\n };\n};\n"]}