vccs 0.6.0 → 1.0.0-beta.2

package/dist/components/{Tooltip.d.ts → tooltip/Tooltip.d.ts}

@@ -1,68 +1,11 @@
-import { PropType, SlotsType } from 'vue';
-import { TooltipIndex, TooltipPayload, TooltipPayloadEntry } from '../state/tooltipSlice';
-import { AxisId } from '../state/cartesianAxisSlice';
-import { ChartCoordinate, Coordinate, LayoutType } from '../types';
-import { TooltipTrigger } from '../types/tooltip';
-import { Point } from '../shape';
-export type ContentType = any | ((props: TooltipContentProps) => any);
-export type TooltipContentProps = {
-    label?: string | number;
-    payload: TooltipPayload;
-    coordinate?: ChartCoordinate;
-    active: boolean;
-    accessibilityLayer: boolean;
-    [key: string]: any;
-};
-type AllowInDimension = {
-    x: boolean;
-    y: boolean;
-};
-type CursorSlotCommon = {
-    class: string | string[];
-    style: {
-        pointerEvents: 'none';
-    };
-    /** Chart area offset — same fields spread by Recharts: left, top, width, height */
-    left: number;
-    top: number;
-    width: number;
-    height: number;
-    payload: TooltipPayload;
-    /** Active tooltip index — named payloadIndex to match Recharts */
-    payloadIndex: string | undefined;
-    [key: string]: any;
-};
-export type CrossCursorSlotProps = CursorSlotCommon & {
-    stroke: string;
-    fill: string;
-    x: number;
-    y: number;
-};
-export type RectangleCursorSlotProps = CursorSlotCommon & {
-    stroke: string;
-    fill: string;
-    x: number;
-    y: number;
-};
-export type SectorCursorSlotProps = CursorSlotCommon & {
-    stroke: string;
-    fill: string;
-    cx: number;
-    cy: number;
-    startAngle: number;
-    endAngle: number;
-    innerRadius: number;
-    outerRadius: number;
-};
-export type CurveCursorSlotProps = CursorSlotCommon & {
-    stroke: string;
-    layout: LayoutType;
-    points: ReadonlyArray<Point>;
-};
-export type CursorSlotProps = CrossCursorSlotProps | RectangleCursorSlotProps | SectorCursorSlotProps | CurveCursorSlotProps;
+import { PropType, SlotsType, VNodeChild } from 'vue';
+import { ChartTransition } from '../../animation/motion.js';
+import { Formatter, TooltipActiveIndex, TooltipPayload, TooltipPayloadEntry, TooltipTrigger } from '../../types/tooltip.js';
+import { AxisId } from '../../types/axisSettings.js';
+import { Coordinate, NameType, Payload, ValueType } from '../../types/index.js';
+import { AllowInDimension, CursorSlotProps, TooltipContentProps } from './types.js';
 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>;
+type UniqueOption<T> = boolean | UniqueFunc<T>;
 export declare const Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     /**
      * If true, then Tooltip is always displayed, once an activeIndex is set by mouse over, or programmatically.
@@ -71,12 +14,14 @@ export declare const Tooltip: import('vue').DefineComponent<import('vue').Extrac
      */
     readonly active: {
         readonly type: BooleanConstructor;
-        readonly default: any;
+        readonly default: undefined;
     };
     /**
      * If true, then Tooltip will show information about hidden series (defaults to false).
      */
     readonly includeHidden: BooleanConstructor;
+    readonly formatter: PropType<Formatter<ValueType, NameType>>;
+    readonly labelFormatter: PropType<(label: string | number | undefined, payload: TooltipPayload) => VNodeChild>;
     readonly allowEscapeViewBox: {
         readonly type: PropType<AllowInDimension>;
         readonly default: () => {
@@ -84,7 +29,6 @@ export declare const Tooltip: import('vue').DefineComponent<import('vue').Extrac
             y: boolean;
         };
     };
-    readonly content: PropType<ContentType>;
     readonly cursor: {
         readonly type: PropType<boolean | object>;
         readonly default: true;
@@ -93,22 +37,30 @@ export declare const Tooltip: import('vue').DefineComponent<import('vue').Extrac
         readonly type: BooleanConstructor;
         readonly default: true;
     };
-    readonly defaultIndex: PropType<number | TooltipIndex>;
+    readonly activeIndex: {
+        readonly type: PropType<TooltipActiveIndex>;
+        readonly default: undefined;
+    };
+    readonly defaultIndex: NumberConstructor;
     readonly isAnimationActive: {
         readonly type: BooleanConstructor;
         readonly default: true;
     };
+    readonly transition: {
+        readonly type: PropType<ChartTransition>;
+        readonly default: undefined;
+    };
     readonly offset: {
         readonly type: NumberConstructor;
         readonly default: 10;
     };
     readonly payloadUniqBy: PropType<UniqueOption<TooltipPayloadEntry>>;
     /**
-     * If portal is defined, then Tooltip will use this element as a target for rendering using Teleport
+     * The selector or element that receives the tooltip, as with Teleport.
      */
-    readonly portal: {
-        readonly type: PropType<HTMLElement | null>;
-        readonly default: any;
+    readonly to: {
+        readonly type: PropType<string | HTMLElement>;
+        readonly default: undefined;
     };
     readonly position: PropType<Partial<Coordinate>>;
     readonly reverseDirection: {
@@ -124,7 +76,7 @@ export declare const Tooltip: import('vue').DefineComponent<import('vue').Extrac
      */
     readonly shared: {
         readonly type: PropType<boolean | undefined>;
-        readonly default: any;
+        readonly default: undefined;
     };
     /**
      * If `hover` then the Tooltip shows on mouse enter and hides on mouse leave.
@@ -157,15 +109,18 @@ export declare const Tooltip: import('vue').DefineComponent<import('vue').Extrac
         readonly type: ObjectConstructor;
         readonly default: () => {};
     };
+    /** Sort rows. By default they keep the order of the series. */
     readonly itemSorter: {
-        readonly type: StringConstructor;
-        readonly default: "name";
+        readonly type: PropType<"name" | "value" | "dataKey" | ((item: Payload<ValueType, NameType>) => number | string)>;
+        readonly default: undefined;
     };
     readonly separator: {
         readonly type: StringConstructor;
         readonly default: " : ";
     };
-}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+}>, () => import("vue/jsx-runtime").JSX.Element | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'update:activeIndex': (_index: TooltipActiveIndex) => true;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     /**
      * If true, then Tooltip is always displayed, once an activeIndex is set by mouse over, or programmatically.
      * If false, then Tooltip is never displayed.
@@ -173,12 +128,14 @@ export declare const Tooltip: import('vue').DefineComponent<import('vue').Extrac
      */
     readonly active: {
         readonly type: BooleanConstructor;
-        readonly default: any;
+        readonly default: undefined;
     };
     /**
      * If true, then Tooltip will show information about hidden series (defaults to false).
      */
     readonly includeHidden: BooleanConstructor;
+    readonly formatter: PropType<Formatter<ValueType, NameType>>;
+    readonly labelFormatter: PropType<(label: string | number | undefined, payload: TooltipPayload) => VNodeChild>;
     readonly allowEscapeViewBox: {
         readonly type: PropType<AllowInDimension>;
         readonly default: () => {
@@ -186,7 +143,6 @@ export declare const Tooltip: import('vue').DefineComponent<import('vue').Extrac
             y: boolean;
         };
     };
-    readonly content: PropType<ContentType>;
     readonly cursor: {
         readonly type: PropType<boolean | object>;
         readonly default: true;
@@ -195,22 +151,30 @@ export declare const Tooltip: import('vue').DefineComponent<import('vue').Extrac
         readonly type: BooleanConstructor;
         readonly default: true;
     };
-    readonly defaultIndex: PropType<number | TooltipIndex>;
+    readonly activeIndex: {
+        readonly type: PropType<TooltipActiveIndex>;
+        readonly default: undefined;
+    };
+    readonly defaultIndex: NumberConstructor;
     readonly isAnimationActive: {
         readonly type: BooleanConstructor;
         readonly default: true;
     };
+    readonly transition: {
+        readonly type: PropType<ChartTransition>;
+        readonly default: undefined;
+    };
     readonly offset: {
         readonly type: NumberConstructor;
         readonly default: 10;
     };
     readonly payloadUniqBy: PropType<UniqueOption<TooltipPayloadEntry>>;
     /**
-     * If portal is defined, then Tooltip will use this element as a target for rendering using Teleport
+     * The selector or element that receives the tooltip, as with Teleport.
      */
-    readonly portal: {
-        readonly type: PropType<HTMLElement | null>;
-        readonly default: any;
+    readonly to: {
+        readonly type: PropType<string | HTMLElement>;
+        readonly default: undefined;
     };
     readonly position: PropType<Partial<Coordinate>>;
     readonly reverseDirection: {
@@ -226,7 +190,7 @@ export declare const Tooltip: import('vue').DefineComponent<import('vue').Extrac
      */
     readonly shared: {
         readonly type: PropType<boolean | undefined>;
-        readonly default: any;
+        readonly default: undefined;
     };
     /**
      * If `hover` then the Tooltip shows on mouse enter and hides on mouse leave.
@@ -259,36 +223,44 @@ export declare const Tooltip: import('vue').DefineComponent<import('vue').Extrac
         readonly type: ObjectConstructor;
         readonly default: () => {};
     };
+    /** Sort rows. By default they keep the order of the series. */
     readonly itemSorter: {
-        readonly type: StringConstructor;
-        readonly default: "name";
+        readonly type: PropType<"name" | "value" | "dataKey" | ((item: Payload<ValueType, NameType>) => number | string)>;
+        readonly default: undefined;
     };
     readonly separator: {
         readonly type: StringConstructor;
         readonly default: " : ";
     };
-}>> & Readonly<{}>, {
-    readonly offset: number;
-    readonly cursor: boolean | object;
-    readonly style: Record<string, any>;
-    readonly isAnimationActive: boolean;
+}>> & Readonly<{
+    "onUpdate:activeIndex"?: ((_index: TooltipActiveIndex) => any) | undefined;
+}>, {
     readonly includeHidden: boolean;
+    readonly style: Record<string, any>;
+    readonly cursor: boolean | object;
+    readonly offset: number;
+    readonly to: string | HTMLElement;
     readonly active: boolean;
-    readonly shared: boolean;
-    readonly trigger: TooltipTrigger;
-    readonly axisId: AxisId;
+    readonly isAnimationActive: boolean;
+    readonly transition: ChartTransition;
     readonly separator: string;
+    readonly activeIndex: TooltipActiveIndex;
     readonly contentStyle: Record<string, any>;
     readonly itemStyle: Record<string, any>;
-    readonly itemSorter: string;
-    readonly portal: HTMLElement;
+    readonly itemSorter: "dataKey" | "name" | "value" | ((item: Payload<ValueType, NameType>) => number | string);
+    readonly labelStyle: Record<string, any>;
     readonly allowEscapeViewBox: AllowInDimension;
     readonly reverseDirection: AllowInDimension;
-    readonly labelStyle: Record<string, any>;
     readonly filterNull: boolean;
+    readonly shared: boolean | undefined;
+    readonly trigger: TooltipTrigger;
+    readonly axisId: AxisId;
 }, SlotsType<{
-    content?: (props: TooltipContentProps) => any;
-    cursor?: (props: CursorSlotProps) => any;
-    default?: () => any;
+    content?: (props: TooltipContentProps) => VNodeChild;
+    cursor?: (props: CursorSlotProps) => VNodeChild;
 }>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
-export default Tooltip;
+export type TooltipSlots = {
+    content?: (props: TooltipContentProps) => VNodeChild;
+    cursor?: (props: CursorSlotProps) => VNodeChild;
+};
+export {};

package/dist/components/tooltip/TooltipBoundingBox.d.ts

@@ -0,0 +1,40 @@
+import { ChartTransition } from '../../animation/motion.js';
+import { CSSProperties, PropType } from 'vue';
+import { ChartCoordinate, Coordinate } from '../../types/index.js';
+import { AllowInDimension } from './types.js';
+export declare const TooltipBoundingBox: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    allowEscapeViewBox: PropType<AllowInDimension>;
+    isAnimationActive: BooleanConstructor;
+    transition: {
+        type: PropType<ChartTransition>;
+        default: undefined;
+    };
+    active: BooleanConstructor;
+    coordinate: PropType<ChartCoordinate>;
+    hasPayload: BooleanConstructor;
+    offset: NumberConstructor;
+    position: PropType<Partial<Coordinate>>;
+    reverseDirection: PropType<AllowInDimension>;
+    viewBox: ObjectConstructor;
+    style: PropType<CSSProperties>;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    allowEscapeViewBox: PropType<AllowInDimension>;
+    isAnimationActive: BooleanConstructor;
+    transition: {
+        type: PropType<ChartTransition>;
+        default: undefined;
+    };
+    active: BooleanConstructor;
+    coordinate: PropType<ChartCoordinate>;
+    hasPayload: BooleanConstructor;
+    offset: NumberConstructor;
+    position: PropType<Partial<Coordinate>>;
+    reverseDirection: PropType<AllowInDimension>;
+    viewBox: ObjectConstructor;
+    style: PropType<CSSProperties>;
+}>> & Readonly<{}>, {
+    active: boolean;
+    isAnimationActive: boolean;
+    transition: ChartTransition;
+    hasPayload: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/components/tooltip/types.d.ts

@@ -0,0 +1,59 @@
+import { TooltipPayload } from '../../types/tooltip.js';
+import { ChartCoordinate, LayoutType } from '../../types/index.js';
+import { Point } from '../../types/shape.js';
+export type TooltipContentProps = {
+    label?: string | number;
+    payload: TooltipPayload;
+    coordinate?: ChartCoordinate;
+    active: boolean;
+    accessibilityLayer: boolean;
+    [key: string]: unknown;
+};
+export type AllowInDimension = {
+    x: boolean;
+    y: boolean;
+};
+type CursorSlotCommon = {
+    class: string | string[];
+    style: {
+        pointerEvents: 'none';
+    };
+    /** Chart area offset — same fields spread by Recharts: left, top, width, height */
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    payload: TooltipPayload;
+    /** Active tooltip index — named payloadIndex to match Recharts */
+    payloadIndex: string | undefined;
+    [key: string]: unknown;
+};
+export type CrossCursorSlotProps = CursorSlotCommon & {
+    stroke: string;
+    fill: string;
+    x: number;
+    y: number;
+};
+export type RectangleCursorSlotProps = CursorSlotCommon & {
+    stroke: string;
+    fill: string;
+    x: number;
+    y: number;
+};
+export type SectorCursorSlotProps = CursorSlotCommon & {
+    stroke: string;
+    fill: string;
+    cx: number;
+    cy: number;
+    startAngle: number;
+    endAngle: number;
+    innerRadius: number;
+    outerRadius: number;
+};
+export type CurveCursorSlotProps = CursorSlotCommon & {
+    stroke: string;
+    layout: LayoutType;
+    points: ReadonlyArray<Point>;
+};
+export type CursorSlotProps = CrossCursorSlotProps | RectangleCursorSlotProps | SectorCursorSlotProps | CurveCursorSlotProps;
+export {};

package/dist/components/types.d.ts

@@ -1,9 +1,9 @@
-import { Coordinate } from '../types';
+import { Coordinate } from '../types/index.js';
 export type RadialCursorPoints = {
     points: [startPoint: Coordinate, endPoint: Coordinate];
-    cx?: number;
-    cy?: number;
-    radius?: number;
-    startAngle?: number;
-    endAngle?: number;
+    cx: number;
+    cy: number;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
 };

package/dist/components/utils.d.ts

@@ -1,4 +1,4 @@
-import { RadialCursorPoints } from './types';
-import { ChartCoordinate, Coordinate, LayoutType } from '../types';
-import { ChartOffsetInternal } from '../utils/types';
+import { RadialCursorPoints } from './types.js';
+import { ChartCoordinate, Coordinate, LayoutType } from '../types/index.js';
+import { ChartOffsetInternal } from '../utils/types.js';
 export declare function getCursorPoints(layout: LayoutType, activeCoordinate: ChartCoordinate, offset: ChartOffsetInternal): [Coordinate, Coordinate] | RadialCursorPoints;

package/dist/container/ClipPath.d.ts

@@ -3,7 +3,7 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         type: StringConstructor;
         required: true;
     };
-}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+}>, () => import("vue/jsx-runtime").JSX.Element | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     clipPathId: {
         type: StringConstructor;
         required: true;

package/dist/container/Layer.d.ts

@@ -1,2 +1,2 @@
 import { SVGAttributes } from 'vue';
-export declare const Layer: import('vue').DefineComponent<SVGAttributes, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SVGAttributes> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export declare const Layer: import('vue').DefineComponent<SVGAttributes, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SVGAttributes> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/container/ResponsiveContainer.d.ts

@@ -1,4 +1,4 @@
-import { CSSProperties, VNode } from 'vue';
+import { CSSProperties } from 'vue';
 export interface ResponsiveContainerProps {
     aspect?: number;
     width?: string | number;
@@ -14,14 +14,11 @@ export interface ResponsiveContainerProps {
     id?: string | number;
     class?: string | number;
     style?: Omit<CSSProperties, keyof ResponsiveContainerProps>;
-    onResize?: (width: number, height: number) => void;
 }
 declare function __VLS_template(): {
     attrs: Partial<{}>;
-    slots: Readonly<{
-        default: () => VNode[];
-    }> & {
-        default: () => VNode[];
+    slots: {
+        default?(_: {}): any;
     };
     refs: {
         containerRef: HTMLDivElement;
@@ -29,16 +26,16 @@ declare function __VLS_template(): {
     rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<ResponsiveContainerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ResponsiveContainerProps> & Readonly<{}>, {
-    width: string | number;
+declare const __VLS_component: import('vue').DefineComponent<ResponsiveContainerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    resize: (width: number, height: number) => any;
+}, string, import('vue').PublicProps, Readonly<ResponsiveContainerProps> & Readonly<{
+    onResize?: ((width: number, height: number) => any) | undefined;
+}>, {
     height: string | number;
+    width: string | number;
     minWidth: string | number;
-    initialDimension: {
-        width: number;
-        height: number;
-    };
     debounce: number;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     containerRef: HTMLDivElement;
 }, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

package/dist/container/Surface.d.ts

@@ -1,11 +1,15 @@
 import { SVGAttributes, StyleValue } from 'vue';
-import { VueClassValue } from '../types';
+import { VueClassValue } from '../types/index.js';
 interface ViewBox {
     x?: number;
     y?: number;
     width?: number;
     height?: number;
 }
+/**
+ * The SVG root of every chart and of legend icons. With `layers`, it also renders the cursor,
+ * graphical and label layers that chart parts teleport into, painted in that order.
+ */
 declare const Surface: import('vue').DefineComponent<Omit<SVGAttributes, "viewBox"> & {
     width: number;
     height: number;
@@ -14,6 +18,8 @@ declare const Surface: import('vue').DefineComponent<Omit<SVGAttributes, "viewBo
     style?: StyleValue;
     title?: string;
     desc?: string;
+    descriptionId?: string;
+    layers?: boolean;
 }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Omit<SVGAttributes, "viewBox"> & {
     width: number;
     height: number;
@@ -22,5 +28,7 @@ declare const Surface: import('vue').DefineComponent<Omit<SVGAttributes, "viewBo
     style?: StyleValue;
     title?: string;
     desc?: string;
+    descriptionId?: string;
+    layers?: boolean;
 }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default Surface;

package/dist/container/useSizeContext.d.ts

@@ -1,11 +1,5 @@
 import { Ref } from 'vue';
-export interface SizeContextValue {
-    sizes: Ref<{
-        width: number;
-        height: number;
-    }>;
-    calculatedWidth: Ref<number>;
-    calculatedHeight: Ref<number>;
-}
-declare const useSizeContext: <T extends SizeContextValue = SizeContextValue>(fallback?: T) => T extends null ? SizeContextValue : SizeContextValue, provideSizeContext: (contextValue: SizeContextValue) => SizeContextValue;
-export { provideSizeContext, useSizeContext };
+import { RoundedSize } from '../hooks/useRoundedSize.js';
+export declare function provideInitialDimension(value: Ref<RoundedSize | undefined>): Ref<RoundedSize | undefined, RoundedSize | undefined>;
+export declare function useInitialDimension(fallback?: Ref<RoundedSize | undefined>): Ref<RoundedSize | undefined>;
+export declare function useInitialDimension(fallback: Ref<RoundedSize | undefined> | null): Ref<RoundedSize | undefined> | null;

package/dist/context/cartesianLabelListContext.d.ts

@@ -1,3 +1,7 @@
 import { Ref } from 'vue';
-import { Data } from '../components/label/types';
-export declare const useCartesianLabelListData: <T extends Ref<readonly Data[], readonly Data[]> = Ref<readonly Data[], readonly Data[]>>(fallback?: T) => T extends null ? Ref<readonly Data[], readonly Data[]> : Ref<readonly Data[], readonly Data[]>, provideCartesianLabelListData: (contextValue: Ref<readonly Data[], readonly Data[]>) => Ref<readonly Data[], readonly Data[]>;
+import { Data } from '../components/label/types.js';
+type LabelListData = Ref<readonly Data[] | undefined>;
+export declare function provideCartesianLabelListData(value: LabelListData): LabelListData;
+export declare function useCartesianLabelListData(fallback?: LabelListData): LabelListData;
+export declare function useCartesianLabelListData(fallback: LabelListData | null): LabelListData | null;
+export {};

package/dist/context/polarLabelViewBoxContext.d.ts

@@ -1,4 +1,4 @@
 import { ComputedRef, InjectionKey } from 'vue';
-import { PolarViewBox } from '../cartesian/type';
+import { PolarViewBox } from '../types/viewBox.js';
 export declare const POLAR_LABEL_VIEW_BOX_KEY: InjectionKey<ComputedRef<PolarViewBox | undefined>>;
 export declare function usePolarLabelViewBox(): ComputedRef<PolarViewBox | undefined>;

package/dist/core/area.d.ts

@@ -0,0 +1,32 @@
+import { ChartData } from '../types/chartData.js';
+import { DataKey } from '../types/common.js';
+import { BaseAxisWithScale } from '../types/axisSettings.js';
+import { Coordinate, TickItem } from '../types/index.js';
+import { AreaPointItem, BaseValue } from '../types/area.js';
+import { StackId } from '../types/tick.js';
+export type { AreaPointItem } from '../types/area.js';
+export type AreaSettings = {
+    connectNulls: boolean;
+    baseValue: BaseValue | undefined;
+    dataKey: DataKey<unknown>;
+    stackId: StackId | undefined;
+    data: ChartData | undefined;
+};
+export type ComputedArea = {
+    points: ReadonlyArray<AreaPointItem>;
+    baseLine: number | Coordinate[];
+    isRange: boolean;
+};
+export declare function computeArea({ areaSettings: { connectNulls, baseValue: itemBaseValue, dataKey }, stackedData, layout, chartBaseValue, xAxis, yAxis, displayedData, dataStartIndex, xAxisTicks, yAxisTicks, bandSize, }: {
+    areaSettings: AreaSettings;
+    stackedData: number[][] | undefined;
+    layout: 'horizontal' | 'vertical';
+    chartBaseValue: BaseValue | undefined;
+    xAxis: BaseAxisWithScale;
+    yAxis: BaseAxisWithScale;
+    displayedData: ChartData;
+    dataStartIndex: number;
+    xAxisTicks: TickItem[];
+    yAxisTicks: TickItem[];
+    bandSize: number;
+}): ComputedArea;

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

@@ -0,0 +1,28 @@
+import { AppliedChartData, ChartData } from '../../types/chartData.js';
+import { CartesianGraphicalItemSettings, ErrorBarsSettings, GraphicalItemSettings, PolarGraphicalItemSettings } from '../../types/graphical.js';
+import { AxisId, AxisType, BaseCartesianAxis } from '../../types/axis.js';
+import { StackId } from '../../types/tick.js';
+export declare function itemAxisPredicate(axisType: AxisType, axisId: AxisId): (item: CartesianGraphicalItemSettings | PolarGraphicalItemSettings) => boolean;
+export declare function graphicalItemsSettings<T extends GraphicalItemSettings>(graphicalItems: ReadonlyArray<T>, axisSettings: BaseCartesianAxis, axisPredicate: (item: T) => boolean | AxisType): T[];
+export declare function filterGraphicalNotStackedItems<T extends {
+    stackId?: StackId;
+}>(cartesianItems: ReadonlyArray<T>): ReadonlyArray<T>;
+export declare function graphicalItemsData(cartesianItems: ReadonlyArray<GraphicalItemSettings>): unknown[];
+export declare function appliedValues(data: ChartData, axisSettings: BaseCartesianAxis, items: ReadonlyArray<GraphicalItemSettings>): AppliedChartData;
+export type AppliedChartDataWithErrorDomain = {
+    /**
+     * This is the value after the dataKey has been applied. Presumably a number? But no guarantees.
+     */
+    value: unknown;
+    /**
+     * This is the error domain, if any, for the current value.
+     * This may be either x or y direction, whatever is applicable.
+     * Assumption is that we're looking at this data from the point of view of a single axis,
+     * and that axis dictates the relevant direction.
+     */
+    errorDomain: ReadonlyArray<number> | undefined;
+};
+export declare function onlyAllowNumbers(data: ReadonlyArray<unknown>): ReadonlyArray<number>;
+export declare function numericalValuesWithErrors(data: ChartData, axisSettings: BaseCartesianAxis, items: ReadonlyArray<GraphicalItemSettings & {
+    errorBars?: ReadonlyArray<ErrorBarsSettings>;
+}>, axisType: AxisType): ReadonlyArray<AppliedChartDataWithErrorDomain>;

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

@@ -0,0 +1,11 @@
+import { CategoricalDomain } from '../../types/categorical.js';
+import { AppliedChartData, ChartData } from '../../types/chartData.js';
+import { AxisDomain, AxisType, BaseCartesianAxis, NumberDomain } from '../../types/axis.js';
+import { LayoutType, StackOffsetType } from '../../types/common.js';
+import { TicksSettings } from '../../types/tick.js';
+import { AppliedChartDataWithErrorDomain } from './data.js';
+export declare const defaultNumericDomain: AxisDomain;
+export declare function getDomainDefinition(axisSettings: BaseCartesianAxis & Partial<TicksSettings>): AxisDomain;
+export declare function mergeDomains(...domains: ReadonlyArray<NumberDomain | undefined>): NumberDomain | undefined;
+export declare function numericalDomain(axisSettings: BaseCartesianAxis, domainDefinition: AxisDomain | undefined, domainOfStackGroups: NumberDomain | undefined, allDataWithErrorDomains: ReadonlyArray<AppliedChartDataWithErrorDomain>, referenceElementsDomain: NumberDomain | undefined): NumberDomain | undefined;
+export declare function axisDomain(axisSettings: BaseCartesianAxis, layout: LayoutType, displayedData: ChartData | undefined, allAppliedValues: AppliedChartData, stackOffsetType: StackOffsetType, axisType: AxisType, numericalDomain: NumberDomain | undefined): NumberDomain | CategoricalDomain | undefined;

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

@@ -0,0 +1,7 @@
+import { AxisId } from '../../types/axis.js';
+/**
+ * The one identity rule for axis ids: `y-axis-id="1"` (a string attribute) and
+ * `:y-axis-id="1"` (a number) name the same axis.
+ */
+export declare function axisKey(id: AxisId): string;
+export declare function sameAxis(a: AxisId | undefined, b: AxisId | undefined): boolean;

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

@@ -0,0 +1,11 @@
+import { LayoutType, Size } from '../../types/common.js';
+import { PolarChartOptions } from '../../types/polarOptions.js';
+export declare function polarViewBox(layout: LayoutType, options: PolarChartOptions | null, innerRadius: number | undefined, outerRadius: number | undefined, size: Size): {
+    cx: number;
+    cy: number;
+    innerRadius: number;
+    outerRadius: number;
+    startAngle: number;
+    endAngle: number;
+    clockWise: boolean;
+} | undefined;