vccs 0.0.1 → 0.2.0

package/dist/types/tick.d.ts

@@ -0,0 +1,55 @@
+import { CartesianViewBox } from '../cartesian/type';
+import { AxisType, CartesianAxisSettings, XAxisOrientation, YAxisOrientation } from './axis';
+import { TickItem } from './common';
+import { RechartsScale } from './scale';
+import { SVGAttributes, VNode } from 'vue';
+/**
+ * Ticks can be any type when the axis is the type of category.
+ *
+ * Ticks must be numbers when the axis is the type of number.
+ */
+export type AxisTick = number | string;
+export type TicksSettings = {
+    allowDecimals: boolean;
+    tickCount?: number;
+    /**
+     * Ticks can be any type when the axis is the type of category
+     * Ticks must be numbers when the axis is the type of number
+     */
+    ticks: ReadonlyArray<AxisTick> | undefined;
+    tick: SVGAttributes | ((props: any) => VNode) | boolean;
+};
+export type TickFormatter = (value: any, index: number) => string;
+export type AxisPropsNeededForTicksGenerator = {
+    axisType?: AxisType;
+    categoricalDomain?: ReadonlyArray<unknown>;
+    duplicateDomain?: ReadonlyArray<unknown>;
+    isCategorical?: boolean;
+    niceTicks?: ReadonlyArray<AxisTick>;
+    /**
+     * The range appears to be only used in Angle Axis - needs further investigation
+     */
+    range?: ReadonlyArray<number>;
+    realScaleType?: 'scaleBand' | string;
+    scale: RechartsScale;
+    tickCount?: number;
+    ticks?: ReadonlyArray<AxisTick>;
+    type?: 'number' | 'category';
+};
+export interface CartesianTickItem extends TickItem {
+    tickCoord?: number;
+    tickSize?: number;
+    isShow?: boolean;
+}
+export type GetTicksInput = {
+    angle: number;
+    interval: CartesianAxisSettings['interval'];
+    minTickGap: number;
+    orientation: XAxisOrientation | YAxisOrientation;
+    tick: CartesianAxisSettings['tick'];
+    tickFormatter: CartesianAxisSettings['tickFormatter'];
+    ticks: ReadonlyArray<CartesianTickItem>;
+    unit: CartesianAxisSettings['unit'];
+    viewBox: CartesianViewBox;
+};
+export type StackId = string | number;

package/dist/types/tooltip.d.ts

@@ -0,0 +1,33 @@
+import { DataKey } from './common';
+/**
+ * null means no active index
+ * string means: whichever index from the chart data it is.
+ * Different charts have different requirements on data shapes,
+ * and are also responsible for providing a function that will accept this index
+ * and return data.
+ */
+export type TooltipIndex = string | null;
+export type TooltipEventType = 'axis' | 'item';
+export type TooltipTrigger = 'hover' | 'click';
+export type TooltipType = 'none';
+export type ValueType = number | string | Array<number | string>;
+export type NameType = number | string;
+export type Formatter<TValue extends ValueType, TName extends NameType> = (value: TValue, name: TName, item: Payload<TValue, TName>, index: number, payload: ReadonlyArray<Payload<TValue, TName>>) => any;
+export interface Payload<TValue extends ValueType, TName extends NameType> {
+    type?: TooltipType;
+    color?: string;
+    name?: TName;
+    value?: TValue;
+    unit?: string;
+    fill?: string;
+    dataKey?: DataKey<any>;
+    nameKey?: DataKey<any>;
+    payload?: any;
+    chartType?: string;
+    stroke?: string;
+    strokeDasharray?: string | number;
+    strokeWidth?: number | string;
+    className?: string;
+    hide?: boolean;
+    formatter?: Formatter<TValue, TName>;
+}

package/dist/utils/ReduceCSSCalc.d.ts

@@ -0,0 +1,2 @@
+export declare function safeEvaluateExpression(expression: string): string;
+export declare function reduceCSSCalc(expression: string): string;

package/dist/utils/VueUtils.d.ts

@@ -0,0 +1,11 @@
+import { FilteredSvgElementType } from '../cartesian/cartesian-grid/const';
+/**
+ * Checks if the property is valid to spread onto an SVG element or onto a specific component
+ * @param {unknown} property property value currently being compared
+ * @param {string} key property key currently being compared
+ * @param {boolean} includeEvents if events are included in spreadable props
+ * @param {boolean} svgElementType checks against map of SVG element types to attributes
+ * @returns {boolean} is prop valid
+ */
+export declare function isValidSpreadableProp(property: unknown, key: string, includeEvents?: boolean, svgElementType?: FilteredSvgElementType): boolean;
+export declare function filterProps(props: Record<string, any> | boolean | unknown, includeEvents: boolean, svgElementType?: FilteredSvgElementType): Record<string, any>;

package/dist/utils/attrs.d.ts

@@ -0,0 +1,46 @@
+import { Size } from '../types';
+import { CSSProperties } from 'vue';
+export declare function getStringSize(text: string | number, style?: CSSProperties): Size;
+export type RequiredKeys<T> = {
+    [K in keyof T]-?: object extends Pick<T, K> ? never : K;
+}[keyof T];
+export type OptionalKeys<T> = {
+    [K in keyof T]-?: object extends Pick<T, K> ? K : never;
+}[keyof T];
+export type DisallowExtraKeys<T, D> = {
+    [K in keyof D]: K extends keyof T ? D[K] : never;
+};
+/**
+ * This type will take a source type `T` and a default type `D` and will return a new type
+ * where all properties that are optional in `T` but required in `D` are made required in the result.
+ * Properties that are required in `T` and optional in `D` will remain required.
+ * Properties that are optional in both `T` and `D` will remain optional.
+ *
+ * This is useful for creating a type that represents the resolved props of a component with default props.
+ */
+export type RequiresDefaultProps<T, D extends Partial<T>> = Pick<T, RequiredKeys<T>> & Required<Pick<T, Extract<OptionalKeys<T>, RequiredKeys<D>>>> & Pick<T, Exclude<OptionalKeys<T>, keyof D>>;
+/**
+ * This function mimics the behavior of the `defaultProps` static property in React.
+ * Functional components do not have a defaultProps property, so this function is useful to resolve default props.
+ *
+ * The common recommendation is to use ES6 destructuring with default values in the function signature,
+ * but you need to be careful there and make sure you destructure all the individual properties
+ * and not the whole object. See the test file for example.
+ *
+ * And because destructuring all properties one by one is a faff, and it's easy to miss one property,
+ * this function exists.
+ *
+ * @param realProps - the props object passed to the component by the user
+ * @param defaultProps - the default props object defined in the component by Recharts
+ * @returns - the props object with all the default props resolved. All `undefined` values are replaced with the default value.
+ */
+export declare function resolveDefaultProps<T, D extends Partial<T>>(realProps: T, defaultProps: D & DisallowExtraKeys<T, D>): RequiresDefaultProps<T, D>;
+/**
+ * merge props and attrs
+ * @param props - props
+ * @param attrs - attrs
+ * @returns merged props
+ */
+export declare function mergePropAttrs<T extends object>(props: T, attrs: any): T & {
+    toObject: () => T;
+};

package/dist/utils/cartesian.d.ts

@@ -0,0 +1,20 @@
+import { Sign } from '../cartesian/type';
+import { Size } from '../types';
+import { CartesianTickItem } from '../types/tick';
+/**
+ * Normalizes the angle so that 0 <= angle < 180.
+ * @param {number} angle Angle in degrees.
+ * @return {number} the normalized angle with a value of at least 0 and never greater or equal to 180.
+ */
+export declare function normalizeAngle(angle: number): number;
+/**
+ * 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} 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;
+export declare function getEquidistantTicks(sign: Sign, boundaries: {
+    start: number;
+    end: number;
+}, getTickSize: (tick: CartesianTickItem, index: number) => number, ticks: ReadonlyArray<CartesianTickItem>, minTickGap: number): ReadonlyArray<CartesianTickItem>;

package/dist/utils/chart.d.ts

@@ -0,0 +1,99 @@
+import { BaseAxisProps } from '../cartesian/axis/type';
+import { PolarViewBoxRequired } from '../cartesian/type';
+import { NormalizedStackId } from '../shape';
+import { BaseAxisWithScale, StackGroup } from '../state/selectors/axisSelectors';
+import { TooltipEntrySettings, TooltipPayloadEntry } from '../state/tooltipSlice';
+import { ChartCoordinate, ChartOffsetRequired, ChartPointer, Coordinate, DataKey, LayoutType, StackOffsetType, TickItem, ValueType } from '../types';
+import { AxisRange, AxisType, NumberDomain } from '../types/axis';
+import { AxisPropsNeededForTicksGenerator, StackId } from '../types/tick';
+import { Series, SeriesPoint } from 'victory-vendor/d3-shape';
+/**
+ * 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 declare function getValueByDataKey<T>(obj: T, dataKey: DataKey<T>, defaultValue?: any): any;
+export declare const MIN_VALUE_REG: RegExp;
+export declare const MAX_VALUE_REG: RegExp;
+/**
+ * Calculate the size between two category
+ * @param  {object} axis  The options of axis
+ * @param  {Array}  ticks The ticks of axis
+ * @param  {boolean} isBar if items in axis are bars
+ * @return {number} Size
+ */
+export declare function getBandSizeOfAxis(axis?: BaseAxisWithScale, ticks?: ReadonlyArray<TickItem>, isBar?: boolean): number | undefined;
+/**
+ * Both value and domain are tuples of two numbers
+ * - but the type stays as array of numbers until we have better support in rest of the app
+ * @param value input that will be truncated
+ * @param domain boundaries
+ * @returns tuple of two numbers
+ */
+export declare function truncateByDomain(value: SeriesPoint<Record<number, number>>, domain: ReadonlyArray<number>): [number, number] | SeriesPoint<Record<number, number>>;
+export declare function getNormalizedStackId(publicStackId: StackId | undefined): NormalizedStackId | undefined;
+export declare function getCateCoordinateOfLine<T extends Record<string, unknown>>({ axis, ticks, bandSize, entry, index, dataKey, }: {
+    axis: {
+        dataKey?: DataKey<T>;
+        allowDuplicatedCategory?: boolean;
+        type?: BaseAxisProps['type'];
+        scale: (v: number) => number;
+    };
+    ticks: Array<TickItem>;
+    bandSize: number;
+    entry: T;
+    index: number;
+    dataKey?: DataKey<T>;
+}): number | null;
+export declare function getChartPointer(event: PointerEvent | MouseEvent): ChartPointer | undefined;
+export declare function getTooltipEntry({ tooltipEntrySettings, dataKey, payload, value, name, }: {
+    tooltipEntrySettings: TooltipEntrySettings;
+    dataKey: DataKey<any>;
+    payload: any;
+    value: ValueType;
+    name: string | undefined;
+}): TooltipPayloadEntry;
+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 inRangeOfSector({ x, y }: Coordinate, viewBox: PolarViewBoxRequired): RangeObj | null;
+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;
+export declare function getDomainOfStackGroups(stackGroups: Record<StackId, StackGroup> | undefined, startIndex: number, endIndex: number): NumberDomain | undefined;
+export declare function checkDomainOfScale(scale: any): void;
+export declare function getTooltipNameProp(nameFromItem: string | number | undefined | unknown, dataKey: DataKey<any> | undefined): string | undefined;
+export declare function isClipDot(dot: any): boolean;
+type OffsetAccessor = (series: Array<Series<Record<string, unknown>, string>>, order: number[]) => void;
+export declare const offsetSign: OffsetAccessor;
+/**
+ * Replaces all negative values with zero when stacking data.
+ *
+ * If all values in the series are positive then this behaves the same as 'none' stacker.
+ *
+ * @param {Array} series from d3-shape Stack
+ * @return {Array} series with applied offset
+ */
+export declare const offsetPositive: OffsetAccessor;
+export declare function getStackedData(data: ReadonlyArray<Record<string, unknown>>, dataKeys: ReadonlyArray<DataKey<any>>, offsetType: StackOffsetType): ReadonlyArray<Series<Record<string, unknown>, DataKey<any>>>;
+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: any;
+    index: number;
+}): number | null;
+export {};

package/dist/utils/const.d.ts

@@ -0,0 +1,30 @@
+/**
+ * We use this attribute to identify which element is the one that the user is touching.
+ * The index is the position of the element in the data array.
+ * This can be either a number (for array-based charts) or a string (for the charts that have a matrix-shaped data).
+ */
+export declare const DATA_ITEM_INDEX_ATTRIBUTE_NAME = "data-recharts-item-index";
+/**
+ * We use this attribute to identify which element is the one that the user is touching.
+ * DataKey works here as a kind of identifier for the element. It's not a perfect identifier for ~two~ three reasons:
+ *
+ * 1. There can be two different elements with the same dataKey; we won't know which is it
+ * 2. DataKey can be a function, and that serialized will be a `[Function: anonymous]` string
+ * which means we will be able to identify that it was a function but can't tell which one.
+ * This will lead to some weird bugs. A proper fix would be to either:
+ * a) use a unique identifier for each element (passed from props, or generated)
+ * b) figure out how to compare the dataKey or graphical item by object reference
+ *
+ * a) is a fuss because we don't have the unique identifier in props,
+ * and b) is possible most of the time except for touchMove events which work differently from mouseEnter/mouseLeave:
+ * - while mouseEnter is fired for the element that the mouse is over,
+ * touchMove is fired for the element where user has started touching. As the finger moves,
+ * we can identify the element that the user is touching by using the elementFromPoint method,
+ * but it keeps calling the handler on the element where touchStart was fired.
+ *
+ * Okay and now I discovered a third reason: the dataKey can be undefined and that's still fine
+ * because if dataKey is undefined then graphical elements assume the dataKey of the axes.
+ * Which makes it a convenient way of using recharts to render a chart but horrible identifier.
+ */
+export declare const DATA_ITEM_DATAKEY_ATTRIBUTE_NAME = "data-recharts-item-data-key";
+export declare const DEFAULT_Y_AXIS_WIDTH = 60;

package/dist/utils/context.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param providerComponentName - The name(s) of the component(s) providing the context.
+ *
+ * There are situations where context can come from multiple components. In such cases, you might need to give an array of component names to provide your context, instead of just a single string.
+ *
+ * @param contextName The description for injection key symbol.
+ */
+export declare function createContext<ContextValue>(providerComponentName: string | string[], contextName?: string): readonly [<T extends ContextValue | null | undefined = ContextValue>(fallback?: T) => T extends null ? ContextValue | null : ContextValue, (contextValue: ContextValue) => ContextValue];

package/dist/utils/createContext.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param providerComponentName - The name(s) of the component(s) providing the context.
+ *
+ * There are situations where context can come from multiple components. In such cases, you might need to give an array of component names to provide your context, instead of just a single string.
+ *
+ * @param contextName The description for injection key symbol.
+ */
+export declare function createContext<ContextValue>(contextName?: string): readonly [<T extends ContextValue | null | undefined = ContextValue>(fallback?: T) => T extends null ? ContextValue | null : ContextValue, (contextValue: ContextValue) => ContextValue];

package/dist/utils/data-utils.d.ts

@@ -0,0 +1,4 @@
+export declare function uniqueId(prefix?: string): string;
+export declare function interpolate(start: unknown, end: number, t: number): number;
+export declare function interpolate(start: unknown, end: null, t: number): null;
+export declare function interpolate(start: unknown, end: number | null, t: number): number | null;

package/dist/utils/data.d.ts

@@ -0,0 +1,13 @@
+export declare function mathSign(value: number): 0 | 1 | -1;
+export declare function hasDuplicate(ary: ReadonlyArray<unknown>): boolean;
+/**
+ * Get percent value of a total value
+ * @param {number|string} percent A percent
+ * @param {number} totalValue     Total value
+ * @param {number} defaultValue   The value returned when percent is undefined or invalid
+ * @param {boolean} validate      If set to be true, the result will be validated
+ * @return {number} value
+ */
+export declare function getPercentValue(percent: number | string, totalValue: number, defaultValue?: number, validate?: boolean): number;
+export declare function findEntryInArray<T>(ary: ReadonlyArray<T>, specifiedKey: number | string | ((entry: T) => unknown), specifiedValue: unknown): T;
+export declare function interpolateNumber(numberA: number | undefined, numberB: number | undefined, t: number): number;

package/dist/utils/events.d.ts

@@ -0,0 +1,12 @@
+import { default as EventEmitter } from 'eventemitter3';
+import { PayloadAction } from '@reduxjs/toolkit';
+import { TooltipSyncState } from '../state/tooltipSlice';
+import { BrushStartEndIndex } from '../state/chartDataSlice';
+declare const eventCenter: EventEmitter<EventTypes>;
+export { eventCenter };
+export declare const TOOLTIP_SYNC_EVENT = "recharts.syncEvent.tooltip";
+export declare const BRUSH_SYNC_EVENT = "recharts.syncEvent.brush";
+interface EventTypes {
+    [TOOLTIP_SYNC_EVENT]: (syncId: number | string, data: PayloadAction<TooltipSyncState>, emitter: symbol) => void;
+    [BRUSH_SYNC_EVENT]: (syncId: number | string, data: BrushStartEndIndex, emitter: symbol) => void;
+}

package/dist/utils/getLinearRegression.d.ts

@@ -0,0 +1,15 @@
+export interface LinearRegressionResult {
+    xmin: number;
+    xmax: number;
+    a: number;
+    b: number;
+}
+/**
+ * The least square linear regression
+ * @param data The array of points
+ * @returns The domain of x, and the parameter of linear function y = ax + b
+ */
+export declare function getLinearRegression(data: ReadonlyArray<{
+    cx?: number;
+    cy?: number;
+}>): LinearRegressionResult;

package/dist/utils/getRelativeCoordinate.d.ts

@@ -0,0 +1,11 @@
+export type RelativePointer = {
+    relativeX: number;
+    relativeY: number;
+};
+type MousePointer = {
+    clientX: number;
+    clientY: number;
+    currentTarget: Element | HTMLElement;
+};
+export declare function getRelativeCoordinate(event: MousePointer): RelativePointer;
+export {};

package/dist/utils/grid.d.ts

@@ -0,0 +1,37 @@
+import { AxisPropsForCartesianGridTicksGeneration } from '../cartesian/cartesian-grid/type';
+import { ChartOffset, TickItem } from '../types';
+/**
+ * Calculate the Coordinates of grid
+ * @param  {Array} ticks           The ticks in axis
+ * @param {number} minValue        The minimum value of axis
+ * @param {number} maxValue        The maximum value of axis
+ * @param {boolean} syncWithTicks  Synchronize grid lines with ticks or not
+ * @return {Array}                 Coordinates
+ */
+export declare function getCoordinatesOfGrid(ticks: ReadonlyArray<TickItem>, minValue: number, maxValue: number, syncWithTicks: boolean): number[];
+export type HorizontalCoordinatesGenerator = (props: {
+    yAxis: AxisPropsForCartesianGridTicksGeneration;
+    width: number;
+    height: number;
+    offset: ChartOffset;
+}, syncWithTicks: boolean) => number[];
+export declare const defaultHorizontalCoordinatesGenerator: HorizontalCoordinatesGenerator;
+export type VerticalCoordinatesGenerator = (props: {
+    xAxis: AxisPropsForCartesianGridTicksGeneration;
+    width: number;
+    height: number;
+    offset: ChartOffset;
+}, syncWithTicks: boolean) => number[];
+export declare const defaultVerticalCoordinatesGenerator: VerticalCoordinatesGenerator;
+export declare function calculateHorizontalPoints(yAxis: AxisPropsForCartesianGridTicksGeneration, width: number, height: number, offset: ChartOffset, syncWithTicks: boolean, customPoints?: number[], horizontalValues?: number[] | string[], horizontalCoordinatesGenerator?: (props: {
+    yAxis: AxisPropsForCartesianGridTicksGeneration;
+    width: number;
+    height: number;
+    offset: ChartOffset;
+}, syncWithTicks: boolean) => number[]): number[];
+export declare function calculateVerticalPoints(xAxis: AxisPropsForCartesianGridTicksGeneration, width: number, height: number, offset: ChartOffset, syncWithTicks: boolean, customPoints?: number[], verticalValues?: number[] | string[], verticalCoordinatesGenerator?: (props: {
+    xAxis: AxisPropsForCartesianGridTicksGeneration;
+    width: number;
+    height: number;
+    offset: ChartOffset;
+}, syncWithTicks: boolean) => number[]): number[];

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './style';
+export * from './validate';
+export * from './data-utils';
+export * from './log';

package/dist/utils/isDomainSpecifiedByUser.d.ts

@@ -0,0 +1,47 @@
+import { AxisDomain, NumberDomain } from '../types/axis';
+export declare function isWellFormedNumberDomain(v: unknown): v is NumberDomain;
+export declare function extendDomain(providedDomain: NumberDomain, boundaryDomain: NumberDomain, allowDataOverflow: boolean): 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;
+/**
+ * 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/utils/legend.d.ts

@@ -0,0 +1,3 @@
+import { LegendSettings } from '../state/legendSlice';
+import { ChartOffset, Size } from '../types';
+export declare function appendOffsetOfLegend(offset: ChartOffset, legendSettings: LegendSettings, legendSize: Size): ChartOffset;

package/dist/utils/log.d.ts

@@ -0,0 +1 @@
+export declare function warn(condition: boolean, format: string, ...args: any[]): void;

package/dist/utils/payload/getUniqPayload.d.ts

@@ -0,0 +1,4 @@
+type UniqueFunc<T> = (entry: T) => unknown;
+export type UniqueOption<T> = boolean | UniqueFunc<T>;
+export declare function getUniqPayload<T>(payload: ReadonlyArray<T>, option: UniqueOption<T>, defaultUniqBy: UniqueFunc<T>): ReadonlyArray<T>;
+export {};

package/dist/utils/polar.d.ts

@@ -0,0 +1,21 @@
+import { PolarViewBoxRequired } from '../cartesian/type';
+import { ChartOffset, Coordinate } from '../types';
+export declare const RADIAN: number;
+export declare const radianToDegree: (angleInRadian: number) => number;
+export declare function distanceBetweenPoints(point: Coordinate, anotherPoint: Coordinate): number;
+export declare function formatAngleOfSector({ startAngle, endAngle }: PolarViewBoxRequired): {
+    startAngle: number;
+    endAngle: number;
+};
+export declare function getAngleOfPoint({ x, y }: Coordinate, { cx, cy }: PolarViewBoxRequired): {
+    radius: number;
+    angle: number;
+    angleInRadian?: undefined;
+} | {
+    radius: number;
+    angle: number;
+    angleInRadian: number;
+};
+export declare function reverseFormatAngleOfSector(angle: number, { startAngle, endAngle }: PolarViewBoxRequired): number;
+export declare function polarToCartesian(cx: number, cy: number, radius: number, angle: number): Coordinate;
+export declare function getMaxRadius(width: number, height: number, offset?: Partial<ChartOffset>): number;

package/dist/utils/props.d.ts

@@ -0,0 +1,15 @@
+import { ComponentObjectPropsOptions } from 'vue';
+/**
+ * 将 defaultProps 的属性值作为 props 的 default 属性
+ * @param props - Vue 组件的 props 定义对象
+ * @param defaultProps - 默认值对象
+ * @returns 新的 Vue 组件 props 对象
+ */
+export declare function applyDefaultProps<T extends ComponentObjectPropsOptions>(props: T, defaultProps: Partial<Record<keyof T, any>>): T;
+/**
+ * 创建带有默认值的 props 对象
+ * @param baseProps - 基础 props 定义
+ * @param defaultProps - 默认值配置
+ * @returns 合并后的 props 对象
+ */
+export declare function createPropsWithDefaults<T extends ComponentObjectPropsOptions>(baseProps: T, defaultProps: Partial<Record<keyof T, any>>): T;

package/dist/utils/resolveDefaultProps.d.ts

@@ -0,0 +1,52 @@
+/**
+ * This function mimics the behavior of the `defaultProps` static property in React.
+ * Functional components do not have a defaultProps property, so this function is useful to resolve default props.
+ *
+ * The common recommendation is to use ES6 destructuring with default values in the function signature,
+ * but you need to be careful there and make sure you destructure all the individual properties
+ * and not the whole object. See the test file for example.
+ *
+ * And because destructuring all properties one by one is a faff, and it's easy to miss one property,
+ * this function exists.
+ *
+ * @param realProps - the props object passed to the component by the user
+ * @param defaultProps - the default props object defined in the component by Recharts
+ * @returns - the props object with all the default props resolved. All `undefined` values are replaced with the default value.
+ */
+export declare function resolveDefaultProps<T, D extends Partial<T>>(realProps: T, defaultProps: D & DisallowExtraKeys<T, D>): RequiresDefaultProps<T, D>;
+/**
+ * Helper type to extract the keys of T that are required.
+ * It iterates through each key K in T. If Pick<T, K> cannot be assigned an empty object {},
+ * it means K is required, so we keep K; otherwise, we discard it (never).
+ * [keyof T] at the end creates a union of the kept keys.
+ */
+export type RequiredKeys<T> = {
+    [K in keyof T]-?: object extends Pick<T, K> ? never : K;
+}[keyof T];
+/**
+ * Helper type to extract the keys of T that are optional.
+ * It iterates through each key K in T. If Pick<T, K> can be assigned an empty object {},
+ * it means K is optional (or potentially missing), so we keep K; otherwise, we discard it (never).
+ * [keyof T] at the end creates a union of the kept keys.
+ */
+export type OptionalKeys<T> = {
+    [K in keyof T]-?: object extends Pick<T, K> ? K : never;
+}[keyof T];
+/**
+ * Helper type to ensure keys of D exist in T.
+ * For each key K in D, if K is also a key of T, keep the type D[K].
+ * If K is NOT a key of T, map it to type `never`.
+ * An object cannot have a property of type `never`, effectively disallowing extra keys.
+ */
+export type DisallowExtraKeys<T, D> = {
+    [K in keyof D]: K extends keyof T ? D[K] : never;
+};
+/**
+ * This type will take a source type `T` and a default type `D` and will return a new type
+ * where all properties that are optional in `T` but required in `D` are made required in the result.
+ * Properties that are required in `T` and optional in `D` will remain required.
+ * Properties that are optional in both `T` and `D` will remain optional.
+ *
+ * This is useful for creating a type that represents the resolved props of a component with default props.
+ */
+export type RequiresDefaultProps<T, D extends Partial<T>> = Pick<T, RequiredKeys<T>> & Required<Pick<T, Extract<OptionalKeys<T>, RequiredKeys<D>>>> & Pick<T, Exclude<OptionalKeys<T>, keyof D>>;