vccs 0.6.0 → 1.0.0-beta.2

package/dist/core/axis/polarSettings.d.ts

@@ -0,0 +1,5 @@
+import { AngleAxisSettings, RadiusAxisSettings } from '../../types/axisSettings.js';
+export declare const implicitAngleAxis: AngleAxisSettings;
+export declare const implicitRadiusAxis: RadiusAxisSettings;
+export declare const implicitRadialBarAngleAxis: AngleAxisSettings;
+export declare const implicitRadialBarRadiusAxis: RadiusAxisSettings;

package/dist/core/axis/position.d.ts

@@ -0,0 +1,76 @@
+import { AxisId } from '../../types/axis.js';
+import { XAxisSettings, YAxisSettings } from '../../types/axisSettings.js';
+import { ChartOffsetRequired } from '../../types/common.js';
+export declare function xAxisPosition(axes: readonly XAxisSettings[], axis: XAxisSettings, offset: ChartOffsetRequired, height: number, id: AxisId): {
+    x: number;
+    y: number;
+};
+export declare function yAxisPosition(axes: readonly YAxisSettings[], axis: YAxisSettings, offset: ChartOffsetRequired, width: number, id: AxisId): {
+    x: number;
+    y: number;
+};
+export declare function gridAxis(axis: XAxisSettings | YAxisSettings, layout: import('../../types/common.js').LayoutType, type: 'xAxis' | 'yAxis', categoricalDomain: readonly unknown[] | undefined, duplicateDomain: readonly unknown[] | undefined, niceTicks: readonly number[] | undefined, range: import('../../types/axis.js').AxisRange | undefined, realScaleType: string | undefined, scale: import('../../types/scale.js').RechartsScale | undefined): {
+    axisType: "xAxis" | "yAxis";
+    categoricalDomain: readonly unknown[] | undefined;
+    duplicateDomain: readonly unknown[] | undefined;
+    isCategorical: boolean;
+    niceTicks: readonly number[] | undefined;
+    range: import('../../types/axis.js').AxisRange | undefined;
+    realScaleType: string | undefined;
+    scale: import('../../types/scale.js').RechartsScale;
+    angle: number;
+    interval: import('../../types/axis.js').AxisInterval;
+    tickFormatter: import('../../index.js').TickFormatter | undefined;
+    unit: string | undefined;
+    allowDecimals: boolean;
+    ticks: ReadonlyArray<import('../../types/tick.js').AxisTick> | undefined;
+    id?: AxisId | undefined;
+    type: "number" | "category";
+    dataKey: import('../../types/base.js').ChartDataKey | undefined;
+    name: string | undefined;
+    allowDuplicatedCategory: boolean;
+    allowDataOverflow: boolean;
+    reversed: boolean;
+    includeHidden: boolean;
+    domain: import('../../types/axis.js').AxisDomain | undefined;
+    mirror: boolean;
+    minTickGap: number;
+    hide: boolean;
+    tickCount: number | undefined;
+    tick: import('vue').SVGAttributes | boolean;
+    padding: import('../../types/axis.js').XAxisPadding;
+    height: number;
+    orientation: import('../../types/axis.js').XAxisOrientation;
+} | {
+    axisType: "xAxis" | "yAxis";
+    categoricalDomain: readonly unknown[] | undefined;
+    duplicateDomain: readonly unknown[] | undefined;
+    isCategorical: boolean;
+    niceTicks: readonly number[] | undefined;
+    range: import('../../types/axis.js').AxisRange | undefined;
+    realScaleType: string | undefined;
+    scale: import('../../types/scale.js').RechartsScale;
+    angle: number;
+    interval: import('../../types/axis.js').AxisInterval;
+    tickFormatter: import('../../index.js').TickFormatter | undefined;
+    unit: string | undefined;
+    allowDecimals: boolean;
+    ticks: ReadonlyArray<import('../../types/tick.js').AxisTick> | undefined;
+    id?: AxisId | undefined;
+    type: "number" | "category";
+    dataKey: import('../../types/base.js').ChartDataKey | undefined;
+    name: string | undefined;
+    allowDuplicatedCategory: boolean;
+    allowDataOverflow: boolean;
+    reversed: boolean;
+    includeHidden: boolean;
+    domain: import('../../types/axis.js').AxisDomain | undefined;
+    mirror: boolean;
+    minTickGap: number;
+    hide: boolean;
+    tickCount: number | undefined;
+    tick: import('vue').SVGAttributes | boolean;
+    padding: import('../../types/axis.js').YAxisPadding;
+    orientation: import('../../types/axis.js').YAxisOrientation;
+    width: number | "auto";
+};

package/dist/core/axis/range.d.ts

@@ -0,0 +1,8 @@
+import { AxisRange, BaseCartesianAxis, XAxisPadding, YAxisPadding } from '../../types/axis.js';
+import { AppliedChartData } from '../../types/chartData.js';
+import { ChartOffsetRequired, LayoutType } from '../../types/common.js';
+export declare function smallestDistance(data: AppliedChartData, axis: BaseCartesianAxis): number | undefined;
+export declare function calculatedPadding(distance: number | undefined, layout: LayoutType, gap: number | string, offset: ChartOffsetRequired, padding: unknown): number;
+export declare function axisRangeWithReverse(axis: BaseCartesianAxis | undefined, range: AxisRange | undefined): AxisRange | undefined;
+export declare function xAxisRange(offset: ChartOffsetRequired, padding: XAxisPadding, calculated: number): AxisRange;
+export declare function yAxisRange(offset: ChartOffsetRequired, layout: LayoutType, padding: YAxisPadding, calculated: number): AxisRange;

package/dist/core/axis/references.d.ts

@@ -0,0 +1,6 @@
+import { ReferenceAreaSettings, ReferenceDotSettings, ReferenceElementSettings, ReferenceLineSettings } from '../../types/reference.js';
+import { AxisId, AxisType, NumberDomain } from '../../types/axis.js';
+export declare function filterReferenceElements<T extends ReferenceElementSettings>(elements: ReadonlyArray<T>, axisType: AxisType, axisId: AxisId): ReadonlyArray<T>;
+export declare function dotsDomain(dots: ReadonlyArray<ReferenceDotSettings> | undefined, axisType: AxisType): NumberDomain | undefined;
+export declare function areasDomain(areas: ReadonlyArray<ReferenceAreaSettings> | undefined, axisType: AxisType): NumberDomain | undefined;
+export declare function linesDomain(lines: ReadonlyArray<ReferenceLineSettings> | undefined, axisType: AxisType): NumberDomain | undefined;

package/dist/core/axis/scale.d.ts

@@ -0,0 +1,21 @@
+import { BaseAxisWithScale, TicksSettings } from '../../types/axisSettings.js';
+import { CategoricalDomain } from '../../types/categorical.js';
+import { AxisRange, AxisType, BaseCartesianAxis, NumberDomain } from '../../types/axis.js';
+import { LayoutType, TickItem } from '../../types/common.js';
+import { AppliedChartData } from '../../types/chartData.js';
+import { RechartsScale } from '../../types/scale.js';
+type AxisWithTicksSettings = BaseCartesianAxis & Partial<TicksSettings>;
+type XorYType = Exclude<AxisType, 'zAxis'>;
+type XorYorZType = AxisType;
+export declare function realScaleType(axisConfig: BaseCartesianAxis | undefined, hasBar: boolean, categoryScale: 'point' | 'band' | 'auto'): string | undefined;
+export declare function scaleFunction(axis: BaseCartesianAxis | undefined, realScaleType: string | undefined, axisDomain: NumberDomain | CategoricalDomain | undefined, axisRange: AxisRange | undefined): RechartsScale | undefined;
+export declare function niceTicks(axisDomain: NumberDomain | CategoricalDomain | undefined, axisSettings: AxisWithTicksSettings, realScaleType: string | undefined): ReadonlyArray<number> | undefined;
+export declare function axisDomainWithNiceTicks(axisSettings: BaseCartesianAxis, domain: NumberDomain | CategoricalDomain | undefined, niceTicks: ReadonlyArray<number> | undefined, axisType: XorYType): NumberDomain | CategoricalDomain | undefined;
+export declare function sortBy(a: unknown, b: unknown): number;
+export declare function duplicateDomain(chartLayout: LayoutType, appliedValues: AppliedChartData, axis: BaseCartesianAxis, axisType: XorYorZType): ReadonlyArray<unknown> | undefined;
+export declare function categoricalDomain(layout: LayoutType, appliedValues: AppliedChartData, axis: AxisWithTicksSettings, axisType: XorYType): ReadonlyArray<unknown> | undefined;
+export declare function graphicalItemTicks(layout: LayoutType, axis: Pick<AxisWithTicksSettings, 'tickCount'> | undefined, scale: RechartsScale | undefined, axisRange: AxisRange | undefined, duplicateDomain: ReadonlyArray<unknown> | undefined, categoricalDomain: ReadonlyArray<unknown> | undefined, axisType: XorYType): TickItem[] | null;
+export declare function inverseTickScale(ticks: readonly TickItem[] | undefined): ((pixel: number) => unknown) | undefined;
+export declare function getBandSizeOfAxis(axis?: BaseAxisWithScale, ticks?: ReadonlyArray<TickItem>, isBar?: boolean): number | undefined;
+export declare function checkDomainOfScale(scale: RechartsScale): void;
+export {};

package/dist/core/axis/settings.d.ts

@@ -0,0 +1,4 @@
+import { XAxisSettings, YAxisSettings, ZAxisSettings } from '../../types/axisSettings.js';
+export declare const implicitXAxis: XAxisSettings;
+export declare const implicitYAxis: YAxisSettings;
+export declare const implicitZAxis: ZAxisSettings;

package/dist/core/axis/stacks.d.ts

@@ -0,0 +1,14 @@
+import { Series } from 'd3-shape';
+import { DataKey, StackOffsetType } from '../../types/common.js';
+import { AxisType, NumberDomain } from '../../types/axis.js';
+import { StackId } from '../../types/tick.js';
+import { ChartData, ChartDataWindow } from '../../types/chartData.js';
+import { MaybeStackedGraphicalItem } from '../../types/graphical.js';
+export declare function getDomainOfStackGroups(stackGroups: Record<StackId, StackGroup> | undefined, startIndex: number, endIndex: number): NumberDomain | undefined;
+export declare function getStackedData<T>(data: ReadonlyArray<unknown>, dataKeys: ReadonlyArray<DataKey<T>>, offsetType: StackOffsetType): ReadonlyArray<Series<unknown, DataKey<T>>>;
+export type StackGroup = {
+    readonly stackedData: ReadonlyArray<Series<unknown, DataKey<unknown>>>;
+    readonly graphicalItems: ReadonlyArray<MaybeStackedGraphicalItem>;
+};
+export declare function stackGroups(displayedData: ChartData | undefined, items: ReadonlyArray<MaybeStackedGraphicalItem>, stackOffsetType: StackOffsetType, reverseStackOrder?: boolean): Record<StackId, StackGroup>;
+export declare function stackDomain(stackGroups: Record<StackId, StackGroup> | undefined, { dataStartIndex, dataEndIndex }: ChartDataWindow, axisType: AxisType): NumberDomain | undefined;

package/dist/core/axis/ticks.d.ts

@@ -0,0 +1,19 @@
+import { LayoutType, TickItem } from '../../types/common.js';
+import { AxisRange, AxisType } from '../../types/axis.js';
+import { AxisPropsNeededForTicksGenerator, AxisTick } from '../../types/tick.js';
+import { RechartsScale } from '../../types/scale.js';
+interface TickAxis {
+    type: 'number' | 'category';
+    ticks: readonly AxisTick[] | undefined;
+    tickCount: number | undefined;
+}
+export declare function axisTicks(layout: LayoutType, axis: TickAxis | undefined, realScaleType: string | undefined, scale: RechartsScale | undefined, niceTicks: ReadonlyArray<number> | undefined, axisRange: AxisRange | undefined, duplicateDomain: ReadonlyArray<unknown> | undefined, categoricalDomain: ReadonlyArray<unknown> | undefined, axisType: AxisType): ReadonlyArray<TickItem> | undefined;
+/**
+ * Get the ticks of an axis
+ * @param  {object}  axis The configuration of an axis
+ * @param {boolean} isGrid Whether or not are the ticks in grid
+ * @param {boolean} isAll Return the ticks of all the points or not
+ * @return {Array}  Ticks
+ */
+export declare function getTicksOfAxis(axis: null | AxisPropsNeededForTicksGenerator, isGrid?: boolean, isAll?: boolean): ReadonlyArray<TickItem> | null;
+export {};

package/dist/core/axis/userDomain.d.ts

@@ -0,0 +1,48 @@
+import { AxisDomain, NumberDomain } from '../../types/axis.js';
+export declare const MIN_VALUE_REG: RegExp;
+export declare const MAX_VALUE_REG: RegExp;
+export declare function isWellFormedNumberDomain(v: unknown): v is NumberDomain;
+/**
+ * So Recharts allows users to provide their own domains,
+ * but it also places some expectations on what the domain is.
+ * We can improve on the typescript typing, but we also need a runtime test
+ to observe that the user-provided domain is well-formed,
+ * that is: an array with exactly two numbers.
+ *
+ * This function does not accept data as an argument.
+ * This is to enable a performance optimization - if the domain is there,
+ * and we know what it is without traversing all the data,
+ * then we don't have to traverse all the data!
+ *
+ * If the user-provided domain is not well-formed,
+ * this function will return undefined - in which case we should traverse the data to calculate the real domain.
+ *
+ * This function is for parsing the numerical domain only.
+ *
+ * @param userDomain external prop, user provided, before validation. Can have various shapes: array, function, special magical strings inside too.
+ * @param allowDataOverflow boolean, provided by users. If true then the data domain wins
+ *
+ * @return [min, max] domain if it's well-formed; undefined if the domain is invalid
+ */
+export declare function numericalDomainSpecifiedWithoutRequiringData(userDomain: AxisDomain | undefined, allowDataOverflow: boolean): NumberDomain | undefined;
+/**
+ * So Recharts allows users to provide their own domains,
+ * but it also places some expectations on what the domain is.
+ * We can improve on the typescript typing, but we also need a runtime test
+ * to observe that the user-provided domain is well-formed,
+ * that is: an array with exactly two numbers.
+ * If the user-provided domain is not well-formed,
+ * this function will return undefined - in which case we should traverse the data to calculate the real domain.
+ *
+ * This function is for parsing the numerical domain only.
+ *
+ * You are probably thinking, why does domain need tick count?
+ * Well it adjusts the domain based on where the "nice ticks" land, and nice ticks depend on the tick count.
+ *
+ * @param userDomain external prop, user provided, before validation. Can have various shapes: array, function, special magical strings inside too.
+ * @param dataDomain calculated from data. Can be undefined, as an option for performance optimization
+ * @param allowDataOverflow provided by users. If true then the data domain wins
+ *
+ * @return [min, max] domain if it's well-formed; undefined if the domain is invalid
+ */
+export declare function parseNumericalUserDomain(userDomain: AxisDomain | undefined, dataDomain: NumberDomain | undefined, allowDataOverflow: boolean): NumberDomain | undefined;

package/dist/core/bar.d.ts

@@ -0,0 +1,22 @@
+import { DataKey, TickItem } from '../types/common.js';
+import { BarPositionPosition, BarRectangleItem, BarSettings } from '../types/bar.js';
+import { BaseAxisWithScale } from '../types/axisSettings.js';
+import { Series } from 'd3-shape';
+import { ChartOffsetInternal } from '../utils/types.js';
+import { MinPointSize } from '../types/shape.js';
+export declare function computeBarRectangles({ layout, barSettings: { dataKey, minPointSize: minPointSizeProp }, pos, bandSize, xAxis, yAxis, xAxisTicks, yAxisTicks, stackedData, displayedData, offset, }: {
+    layout: 'horizontal' | 'vertical';
+    barSettings: {
+        dataKey: BarSettings['dataKey'] | undefined;
+        minPointSize?: MinPointSize;
+    };
+    pos: BarPositionPosition;
+    bandSize: number;
+    xAxis: BaseAxisWithScale;
+    yAxis: BaseAxisWithScale;
+    xAxisTicks: TickItem[];
+    yAxisTicks: TickItem[];
+    stackedData: Series<unknown, DataKey<unknown>> | undefined;
+    offset: ChartOffsetInternal;
+    displayedData: readonly unknown[];
+}): ReadonlyArray<BarRectangleItem> | undefined;

package/dist/core/barSizing.d.ts

@@ -0,0 +1,43 @@
+import { Series } from 'd3-shape';
+import { MaybeStackedGraphicalItem } from '../types/graphical.js';
+import { StackGroup } from './axis/stacks.js';
+import { DataKey } from '../types/common.js';
+import { StackId } from '../types/tick.js';
+import { BarPositionPosition } from '../types/bar.js';
+export type { MaybeStackedGraphicalItem } from '../types/graphical.js';
+type BarCategory = {
+    stackId: StackId | undefined;
+    /**
+     * List of dataKeys of items stacked at this position.
+     * All of these Bars are either sharing the same stackId,
+     * or this is an array with one Bar because it has no stackId defined.
+     *
+     * This structure limits us to having one dataKey only once per stack which I think is reasonable.
+     * People who want to have the same data twice can duplicate their data to have two distinct dataKeys.
+     */
+    dataKeys: ReadonlyArray<DataKey<unknown>>;
+    /**
+     * Width (in horizontal chart) or height (in vertical chart) of this stack of items
+     */
+    barSize: number;
+};
+export type SizeList = ReadonlyArray<BarCategory>;
+export declare function barSizeList(allBars: ReadonlyArray<MaybeStackedGraphicalItem>, globalSize: string | number | undefined, totalSize?: number): BarCategory[];
+export type BarWithPosition = {
+    stackId: StackId | undefined;
+    /**
+     * List of dataKeys of items stacked at this position.
+     * All of these Bars are either sharing the same stackId,
+     * or this is an array with one Bar because it has no stackId defined.
+     *
+     * This structure limits us to having one dataKey only once per stack which I think is reasonable.
+     * People who want to have the same data twice can duplicate their data to have two distinct dataKeys.
+     */
+    dataKeys: ReadonlyArray<DataKey<unknown>>;
+    /**
+     * Position of this stack in absolute pixels measured from the start of the chart
+     */
+    position: BarPositionPosition;
+};
+export declare function barPositions(sizeList: SizeList | undefined, globalMaxBarSize: number | undefined, barGap: string | number, barCategoryGap: string | number, barBandSize: number | undefined, bandSize: number | undefined, childMaxBarSize: number | undefined): readonly BarWithPosition[];
+export declare function stackedData(stackGroups: Record<StackId, StackGroup> | undefined, barSettings: MaybeStackedGraphicalItem | undefined): Series<unknown, DataKey<unknown>> | undefined;

package/dist/core/color.d.ts

@@ -0,0 +1,21 @@
+import { CartesianGraphicalItemType } from '../types/graphical.js';
+export type SeriesType = CartesianGraphicalItemType | 'pie' | 'radar' | 'radialBar' | 'funnel';
+/**
+ * The colour that stands for a whole series: its legend icon, tooltip swatch and active dot.
+ * Outline series (area, line, radar) are their stroke unless it is hidden; filled shapes are
+ * their fill.
+ */
+export declare function mainColor(type: SeriesType, { stroke, fill }: {
+    stroke?: string;
+    fill?: string;
+}): string | undefined;
+/**
+ * The colour of one data entry (a sector, trapezoid or bar): a `<Cell fill>` wins, then the
+ * row's own `fill`, then the series fill, then the palette colour for its position.
+ */
+export declare function entryColor({ cell, row, seriesFill, index }: {
+    cell?: unknown;
+    row?: unknown;
+    seriesFill?: string;
+    index: number;
+}): string;

package/dist/core/coordinates.d.ts

@@ -0,0 +1,34 @@
+import { SeriesPoint } from 'd3-shape';
+import { DataKey, TickItem } from '../types/common.js';
+import { StackId } from '../types/tick.js';
+import { BaseAxisWithScale } from '../types/axisSettings.js';
+import { NormalizedStackId } from '../types/shape.js';
+export declare function truncateByDomain(value: SeriesPoint<unknown>, domain: ReadonlyArray<number>): [number, number] | SeriesPoint<unknown>;
+export declare function getNormalizedStackId(publicStackId: StackId | undefined): NormalizedStackId | undefined;
+export declare function getCateCoordinateOfLine<T>({ axis, ticks, bandSize, entry, index, dataKey, }: {
+    axis: {
+        dataKey?: DataKey<T>;
+        allowDuplicatedCategory?: boolean;
+        type?: 'number' | 'category';
+        scale: (v: number) => number;
+    };
+    ticks: Array<TickItem>;
+    bandSize: number;
+    entry: unknown;
+    index: number;
+    dataKey?: DataKey<T>;
+}): number | null;
+export declare function getBaseValueOfBar({ numericAxis }: {
+    numericAxis: BaseAxisWithScale;
+}): number | unknown;
+export declare function getCateCoordinateOfBar({ axis, ticks, offset, bandSize, entry, index, }: {
+    axis: BaseAxisWithScale;
+    ticks: ReadonlyArray<TickItem>;
+    offset: number;
+    bandSize: number;
+    entry: unknown;
+    index: number;
+}): number | null;
+/** Dots draw when the `dot` option is on, or always for a single point, which has no line. */
+export declare function shouldRenderDots(points: readonly unknown[] | undefined, dot: unknown): boolean;
+export declare function isClipDot(dot: unknown): boolean;

package/dist/core/data.d.ts

@@ -0,0 +1,2 @@
+import { DataKey } from '../types/common.js';
+export declare function getValueByDataKey<T>(obj: unknown, dataKey: DataKey<T> | undefined, defaultValue?: unknown): any;

package/dist/core/errorBar.d.ts

@@ -0,0 +1,15 @@
+import { BaseAxisWithScale } from '../types/axisSettings.js';
+import { ErrorBarDirection } from '../types/bar.js';
+export interface ErrorBarDataItem {
+    x: number | null | undefined;
+    y: number | null | undefined;
+    value: number;
+    errorVal?: number[] | number;
+}
+export interface LineCoordinate {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+export declare function errorBarLines({ x, y, value, errorVal }: ErrorBarDataItem, axis: BaseAxisWithScale, direction: ErrorBarDirection, offset: number, width: number): LineCoordinate[] | null;

package/dist/core/funnel.d.ts

@@ -0,0 +1,17 @@
+import { ChartOffset, TooltipType } from '../types/index.js';
+import { FunnelComposedData } from '../types/funnel.js';
+import { DataKey } from '../types/common.js';
+export type ResolvedFunnelSettings = {
+    dataKey: DataKey<unknown>;
+    data: unknown[] | undefined;
+    nameKey: DataKey<unknown>;
+    tooltipType?: TooltipType;
+    lastShapeType?: 'triangle' | 'rectangle';
+    reversed?: boolean;
+    customWidth?: string | number;
+    presentationProps: Record<string, unknown> | null;
+};
+export declare function funnelTrapezoids(offset: ChartOffset, settings: ResolvedFunnelSettings, chartData: unknown[] | undefined): FunnelComposedData | {
+    trapezoids: never[];
+    data: unknown[] | undefined;
+};

package/dist/core/interaction.d.ts

@@ -0,0 +1,18 @@
+import { ActiveTooltipProps } from '../types/tooltip.js';
+import { AxisRange, AxisType } from '../types/axis.js';
+import { ChartOffsetRequired, ChartPointer, LayoutType, TickItem } from '../types/index.js';
+import { PolarViewBoxRequired } from '../types/viewBox.js';
+import { ChartCoordinate } from '../types/common.js';
+export declare function activeProps(chartEvent: ChartPointer | undefined, layout: LayoutType | undefined, polarViewBox: PolarViewBoxRequired | undefined, tooltipAxisType: AxisType | undefined, tooltipAxisRange: AxisRange | undefined, tooltipTicks: ReadonlyArray<TickItem> | undefined | null, orderedTooltipTicks: ReadonlyArray<TickItem> | undefined, offset: ChartOffsetRequired): ActiveTooltipProps | undefined;
+export type RangeObj = {
+    x?: number;
+    y?: number;
+    cx?: number;
+    cy?: number;
+    angle?: number;
+    radius?: number;
+};
+export declare function calculateTooltipPos(rangeObj: RangeObj, layout: LayoutType): number | undefined;
+export declare function inRange(x: number, y: number, layout: LayoutType, polarViewBox: PolarViewBoxRequired | undefined, offset: ChartOffsetRequired): RangeObj | null;
+export declare function calculateActiveTickIndex(coordinate: number, ticks: ReadonlyArray<TickItem>, unsortedTicks: ReadonlyArray<TickItem>, axisType: AxisType | undefined, range: AxisRange | undefined): number;
+export declare function getActiveCoordinate(layout: LayoutType, tooltipTicks: readonly TickItem[], activeIndex: number, rangeObj: RangeObj): ChartCoordinate;

package/dist/core/layout.d.ts

@@ -0,0 +1,43 @@
+import { ChartOffset, Margin, Size } from '../types/common.js';
+import { AxisId, XAxisSettings, YAxisSettings } from '../types/axis.js';
+interface LayoutLegendSettings {
+    layout: string;
+    align: 'left' | 'center' | 'right';
+    verticalAlign: 'top' | 'middle' | 'bottom';
+    position?: string | {
+        x: number | string;
+        y: number | string;
+    };
+    offset?: number;
+}
+interface BrushSettings {
+    x: number | undefined;
+    y: number | undefined;
+    width: number | undefined;
+    height: number;
+}
+export declare function registeredAxes<T extends {
+    id?: AxisId;
+}>(axes: readonly T[]): T[];
+export declare function chartOffset(size: Size, margin: Margin | undefined, brushHeight: number, xAxes: readonly XAxisSettings[], yAxes: readonly YAxisSettings[], legendSettings: LayoutLegendSettings, legendSize: Size): ChartOffset;
+export declare function chartViewBox(offset: ChartOffset): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare function brushDimensions(brush: BrushSettings, offset: ChartOffset, margin: Margin | undefined): {
+    height: number;
+    x: number;
+    y: number;
+    width: number;
+};
+export declare function appendOffsetOfLegend(offset: ChartOffset, legendSettings: LayoutLegendSettings, legendSize: Size): ChartOffset;
+/** Outside legends use the margin-inset chart area rather than the axis-inset plot. */
+export declare function legendArea(size: Size, margin: Margin): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export {};

package/dist/core/line.d.ts

@@ -0,0 +1,14 @@
+import { BaseAxisWithScale } from '../types/axisSettings.js';
+import { TickItem } from '../types/index.js';
+import { DataKey, LayoutType } from '../types/common.js';
+import { LinePointItem } from '../types/line.js';
+export declare function computeLinePoints({ layout, xAxis, yAxis, xAxisTicks, yAxisTicks, dataKey, bandSize, displayedData, }: {
+    layout: LayoutType | undefined;
+    xAxis: BaseAxisWithScale;
+    yAxis: BaseAxisWithScale;
+    xAxisTicks: TickItem[];
+    yAxisTicks: TickItem[];
+    dataKey: DataKey<unknown> | undefined;
+    bandSize: number;
+    displayedData: readonly unknown[];
+}): ReadonlyArray<LinePointItem>;

package/dist/{state/selectors/pieSelectors.d.ts → core/pie.d.ts}

@@ -1,16 +1,16 @@
-import { RechartsRootState } from '../store';
-import { ChartData } from '../chartDataSlice';
-import { ChartOffset, Coordinate, DataKey, TooltipType } from '../../types';
-import { LegendType } from '../../types/legend';
-import { LegendPayload } from '../../components/DefaultLegendContent';
+import { ChartDataKey } from '../types/base.js';
+import { ChartOffset, Coordinate } from '../types/common.js';
+import { TooltipType } from '../types/tooltip.js';
+import { ChartData } from '../types/chartData.js';
+import { LegendPayload, LegendType } from '../types/legend.js';
 export type ResolvedPieSettings = {
     name?: string | number | undefined;
-    nameKey: DataKey<any>;
+    nameKey: ChartDataKey;
     data?: ChartData | undefined;
-    dataKey: DataKey<any> | undefined;
+    dataKey: ChartDataKey | undefined;
     tooltipType?: TooltipType | undefined;
     legendType?: LegendType;
-    fill: string;
+    fill: string | undefined;
     cx?: number | string;
     cy?: number | string;
     startAngle?: number;
@@ -18,11 +18,11 @@ export type ResolvedPieSettings = {
     paddingAngle?: number;
     minAngle?: number;
     innerRadius?: number | string;
-    outerRadius?: number | string | ((element: any) => number);
+    outerRadius?: number | string | ((element: unknown) => number);
     cornerRadius?: number | string;
     presentationProps?: Record<string, string>;
 };
-export type PieCoordinate = {
+type PieCoordinate = {
     cx: number;
     cy: number;
     innerRadius: number;
@@ -39,17 +39,15 @@ export type PieSectorDataItem = ResolvedPieSettings & PieCoordinate & {
     midAngle: number;
     middleRadius: number;
     paddingAngle: number;
-    payload: any;
+    payload: unknown;
     fill: string;
     tooltipPosition: Coordinate;
-    dataKey: DataKey<any>;
+    dataKey: ChartDataKey;
 };
-export declare const selectDisplayedData: (state: RechartsRootState, pieSettings: ResolvedPieSettings) => ChartData | undefined;
-export declare const selectPieLegend: (state: RechartsRootState, pieSettings: ResolvedPieSettings) => ReadonlyArray<LegendPayload> | undefined;
-export declare const selectSynchronisedPieSettings: (state: RechartsRootState, pieSettings: ResolvedPieSettings) => ResolvedPieSettings | undefined;
 export declare function computePieSectors({ pieSettings, displayedData, offset, }: {
     pieSettings: ResolvedPieSettings;
     displayedData: ChartData;
     offset: ChartOffset;
 }): ReadonlyArray<PieSectorDataItem> | undefined;
-export declare const selectPieSectors: (state: RechartsRootState, pieSettings: ResolvedPieSettings) => Readonly<PieSectorDataItem[]> | undefined;
+export declare function pieLegend(displayedData: ChartData | undefined, settings: ResolvedPieSettings, cells?: readonly unknown[]): readonly LegendPayload[] | undefined;
+export {};

package/dist/core/polygon.d.ts

@@ -0,0 +1,5 @@
+/** A closed SVG path through the points: `Mx,yLx,y…Z`. */
+export declare function polygonPath(points: ReadonlyArray<{
+    x: number;
+    y: number;
+}>): string;

package/dist/core/radar.d.ts

@@ -0,0 +1,20 @@
+import { ChartDataKey } from '../types/base.js';
+import { AngleAxisForRadar, RadarComposedData, RadiusAxisForRadar } from '../types/radar.js';
+export declare function computeRadarPoints({ radiusAxis, angleAxis, displayedData, dataKey, bandSize, }: {
+    radiusAxis: RadiusAxisForRadar;
+    angleAxis: AngleAxisForRadar;
+    displayedData: unknown[];
+    dataKey: ChartDataKey;
+    bandSize: number;
+}): RadarComposedData;
+export declare function getSinglePolygonPath(points: ReadonlyArray<{
+    x: number;
+    y: number;
+}>): string;
+export declare function getRangePath(points: ReadonlyArray<{
+    x: number;
+    y: number;
+}>, baseLinePoints: ReadonlyArray<{
+    x: number;
+    y: number;
+}>): string;

package/dist/core/radialBar.d.ts

@@ -0,0 +1,36 @@
+import { ChartDataKey, DataKey } from '../types/base.js';
+import { Series } from 'd3-shape';
+import { BaseAxisWithScale } from '../types/axisSettings.js';
+import { LayoutType, TickItem } from '../types/common.js';
+import { BarPositionPosition } from '../types/bar.js';
+import { StackId } from '../types/tick.js';
+import { MaybeStackedGraphicalItem } from '../types/graphical.js';
+import { RadialBarDataItem } from '../types/radialBar.js';
+import { LegendPayload, LegendType } from '../types/legend.js';
+export interface RadialBarSettings extends MaybeStackedGraphicalItem {
+    dataKey: ChartDataKey | undefined;
+    minPointSize: number;
+    stackId: StackId | undefined;
+    maxBarSize: number | undefined;
+}
+export declare function computeRadialBarDataItems({ displayedData, stackedData, dataStartIndex, stackedDomain, dataKey, baseValue, layout, radiusAxis, radiusAxisTicks, bandSize, pos, angleAxis, minPointSize, cx, cy, angleAxisTicks, startAngle: rootStartAngle, endAngle: rootEndAngle, }: {
+    displayedData: ReadonlyArray<unknown>;
+    stackedData: Series<unknown, DataKey<unknown>> | undefined;
+    dataStartIndex: number;
+    stackedDomain: ReadonlyArray<unknown> | null;
+    dataKey: ChartDataKey | undefined;
+    baseValue: number | unknown;
+    layout: LayoutType;
+    radiusAxis: BaseAxisWithScale;
+    radiusAxisTicks: ReadonlyArray<TickItem>;
+    bandSize: number;
+    pos: BarPositionPosition;
+    angleAxis: BaseAxisWithScale;
+    minPointSize: number;
+    cx: number;
+    cy: number;
+    angleAxisTicks: ReadonlyArray<TickItem>;
+    startAngle: number;
+    endAngle: number;
+}): ReadonlyArray<RadialBarDataItem>;
+export declare function radialBarLegend(data: readonly unknown[] | undefined, legendType: LegendType): readonly LegendPayload[];

package/dist/core/rectangle.d.ts

@@ -0,0 +1,10 @@
+import { Size } from '../types/index.js';
+/**
+ * Calculates the width of the largest horizontal line that fits inside a rectangle that is displayed at an angle.
+ * @param {object} size Width and height of the text in a horizontal position.
+ * @param {number} size.width Horizontal text width.
+ * @param {number} size.height Horizontal text height.
+ * @param {number} angle Angle in degrees in which the text is displayed.
+ * @return {number} The width of the largest horizontal line that fits inside a rectangle that is displayed at an angle.
+ */
+export declare function getAngledRectangleWidth({ width, height }: Size, angle?: number | undefined): number;

package/dist/core/scatter.d.ts

@@ -0,0 +1,18 @@
+import { BaseAxisWithScale, ZAxisWithScale } from '../types/axisSettings.js';
+import { DataKey, ScatterPointItem, TickItem } from '../types/common.js';
+import { TooltipType } from '../types/tooltip.js';
+export type ResolvedScatterSettings = {
+    data: readonly unknown[] | undefined;
+    dataKey: DataKey<unknown> | undefined;
+    tooltipType: TooltipType | undefined;
+    name: string | undefined;
+};
+export declare function computeScatterPoints({ displayedData, xAxis, yAxis, zAxis, scatterSettings, xAxisTicks, yAxisTicks, }: {
+    displayedData: ReadonlyArray<unknown>;
+    xAxis: BaseAxisWithScale;
+    yAxis: BaseAxisWithScale;
+    zAxis: ZAxisWithScale | undefined;
+    scatterSettings: ResolvedScatterSettings;
+    xAxisTicks: ReadonlyArray<TickItem> | undefined;
+    yAxisTicks: ReadonlyArray<TickItem> | undefined;
+}): ReadonlyArray<ScatterPointItem>;

package/dist/core/tooltip.d.ts

@@ -0,0 +1,16 @@
+import { AxisRange, AxisType } from '../types/axis.js';
+import { AxisWithTicksSettings } from '../types/axisSettings.js';
+import { TooltipActiveIndex, TooltipEntrySettings, TooltipPayload, TooltipPayloadConfiguration, TooltipPayloadEntry, TooltipPayloadSearcher } from '../types/tooltip.js';
+import { ChartOffsetRequired, Coordinate, DataKey, LayoutType, Size, TickItem, TooltipEventType, ValueType } from '../types/index.js';
+import { RechartsScale } from '../types/scale.js';
+export declare function tooltipPayload(tooltipPayloadConfigurations: ReadonlyArray<TooltipPayloadConfiguration>, activeIndex: TooltipActiveIndex, tooltipAxis: Pick<AxisWithTicksSettings, 'dataKey' | 'allowDuplicatedCategory'> | undefined, activeLabel: string | number | undefined, tooltipPayloadSearcher: TooltipPayloadSearcher | undefined, tooltipEventType: TooltipEventType | undefined, payloadKey?: string): TooltipPayload | undefined;
+export declare function tooltipTicks(layout: LayoutType, axis: Pick<AxisWithTicksSettings, 'type'>, realScaleType: string | undefined, scale: RechartsScale | undefined, range: AxisRange | undefined, duplicateDomain: ReadonlyArray<unknown> | undefined, categoricalDomain: ReadonlyArray<unknown> | undefined, axisType: Exclude<AxisType, 'zAxis'>): ReadonlyArray<TickItem> | null;
+export declare function getTooltipEntry({ tooltipEntrySettings, dataKey, payload, value, name, }: {
+    tooltipEntrySettings: TooltipEntrySettings;
+    dataKey: DataKey<unknown>;
+    payload: unknown;
+    value: ValueType | undefined;
+    name: string | undefined;
+}): TooltipPayloadEntry;
+export declare function tooltipCoordinate(type: TooltipEventType, layout: LayoutType, tick: TickItem | undefined, size: Size, offset: ChartOffsetRequired, position: Coordinate | undefined, fallback: Coordinate | undefined): Coordinate | undefined;
+export declare function getTooltipNameProp(nameFromItem: unknown, dataKey: DataKey<unknown> | undefined): string | undefined;