vccs 0.6.0 → 1.0.0-beta.2

package/dist/components/label/LabelView.d.ts

@@ -0,0 +1,79 @@
+import { SlotsType } from 'vue';
+import { LabelSlots } from './types.js';
+export declare const LabelView: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    parentViewBox: {
+        type: import('vue').PropType<import('./types.js').ViewBox>;
+    };
+    index: {
+        type: NumberConstructor;
+    };
+    id: {
+        type: StringConstructor;
+    };
+    class: {
+        default: string;
+        type: import('vue').PropType<import('../../types/index.js').VueClassValue>;
+    };
+    viewBox: {
+        type: import('vue').PropType<import('./types.js').ViewBox>;
+    };
+    value: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    formatter: {
+        type: import('vue').PropType<import('./types.js').LabelFormatter>;
+    };
+    offset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    position: {
+        type: import('vue').PropType<import('./types.js').LabelPosition>;
+    };
+    textBreakAll: {
+        type: BooleanConstructor;
+    };
+    angle: {
+        type: NumberConstructor;
+    };
+}>, () => import('vue').VNodeChild, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    parentViewBox: {
+        type: import('vue').PropType<import('./types.js').ViewBox>;
+    };
+    index: {
+        type: NumberConstructor;
+    };
+    id: {
+        type: StringConstructor;
+    };
+    class: {
+        default: string;
+        type: import('vue').PropType<import('../../types/index.js').VueClassValue>;
+    };
+    viewBox: {
+        type: import('vue').PropType<import('./types.js').ViewBox>;
+    };
+    value: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    formatter: {
+        type: import('vue').PropType<import('./types.js').LabelFormatter>;
+    };
+    offset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    position: {
+        type: import('vue').PropType<import('./types.js').LabelPosition>;
+    };
+    textBreakAll: {
+        type: BooleanConstructor;
+    };
+    angle: {
+        type: NumberConstructor;
+    };
+}>> & Readonly<{}>, {
+    class: import('../../types/index.js').VueClassValue;
+    offset: number;
+    textBreakAll: boolean;
+}, SlotsType<LabelSlots>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

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

@@ -1,12 +1,20 @@
-import { ViewBox } from '../../cartesian/type';
-import { DataKey, VuePropsToType } from '../../types';
-import { PropType, VNode } from 'vue';
+import { PropType, VNodeChild } from 'vue';
+import { CartesianViewBox, PolarViewBox, ViewBox } from '../../types/viewBox.js';
+import { DataKey, VuePropsToType } from '../../types/index.js';
 export type { ViewBox };
-export interface Data {
-    value?: number | string | Array<number | string>;
-    payload?: any;
+export interface Data extends Omit<CartesianViewBox, 'x' | 'y'>, Omit<PolarViewBox, 'innerRadius' | 'startAngle'> {
+    x?: number | null;
+    y?: number | null;
+    innerRadius?: number | null;
+    startAngle?: number | null;
+    value?: unknown;
+    payload?: unknown;
     parentViewBox?: ViewBox;
     fill?: string;
+    /** Set by a series while the shape behind the label fades in or out. */
+    opacity?: number;
+    /** Identity of the shape behind the label across data changes; defaults to the index. */
+    key?: PropertyKey;
 }
 export type LabelPosition = 'top' | 'left' | 'right' | 'bottom' | 'inside' | 'outside' | 'insideLeft' | 'insideRight' | 'insideTop' | 'insideBottom' | 'insideTopLeft' | 'insideBottomLeft' | 'insideTopRight' | 'insideBottomRight' | 'insideStart' | 'insideEnd' | 'end' | 'center' | 'centerTop' | 'centerBottom' | 'middle' | {
     x?: number;
@@ -21,13 +29,13 @@ export declare const LabelListVueProps: {
     };
     valueAccessor: {
         type: PropType<(entry: Data, index: number) => string | number>;
-        default: (entry: Data) => string | number;
+        default: (entry: Data) => any;
     };
     clockWise: {
         type: BooleanConstructor;
     };
     dataKey: {
-        type: PropType<DataKey<Record<string, any>>>;
+        type: PropType<DataKey<Record<string, unknown>>>;
     };
     textBreakAll: {
         type: BooleanConstructor;
@@ -41,24 +49,26 @@ export declare const LabelListVueProps: {
     angle: {
         type: NumberConstructor;
     };
+    /** Writes the label text. Receives the raw value, which can be `null` or an object in messy data. */
+    formatter: {
+        type: PropType<LabelListFormatter>;
+    };
 };
 export type LabelFormatter = (label: string | number | undefined) => string | number | undefined;
+export type LabelListFormatter = (value: unknown) => string | number | undefined;
 export declare const LabelVueProps: {
     id: {
         type: StringConstructor;
     };
     class: {
         default: string;
-        type: PropType<import('../../types').VueClassValue>;
+        type: PropType<import('../../types/index.js').VueClassValue>;
     };
     viewBox: {
         type: PropType<ViewBox>;
     };
-    parentViewBox: {
-        type: PropType<ViewBox>;
-    };
     value: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: (StringConstructor | NumberConstructor)[];
     };
     formatter: {
         type: PropType<LabelFormatter>;
@@ -76,13 +86,58 @@ export declare const LabelVueProps: {
     angle: {
         type: NumberConstructor;
     };
+};
+export declare const LabelViewVueProps: {
+    parentViewBox: {
+        type: PropType<ViewBox>;
+    };
     index: {
         type: NumberConstructor;
     };
+    id: {
+        type: StringConstructor;
+    };
+    class: {
+        default: string;
+        type: PropType<import('../../types/index.js').VueClassValue>;
+    };
+    viewBox: {
+        type: PropType<ViewBox>;
+    };
+    value: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    formatter: {
+        type: PropType<LabelFormatter>;
+    };
+    offset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    position: {
+        type: PropType<LabelPosition>;
+    };
+    textBreakAll: {
+        type: BooleanConstructor;
+    };
+    angle: {
+        type: NumberConstructor;
+    };
 };
+export type LabelViewProps = VuePropsToType<typeof LabelViewVueProps>;
 export type LabelProps = VuePropsToType<typeof LabelVueProps>;
 export interface LabelSlots {
-    content: (props: LabelProps & {
+    content?: (props: LabelProps & {
         viewBox: ViewBox;
-    }) => VNode;
+    }) => VNodeChild;
+}
+export type LabelListSlotProps = Omit<LabelProps, 'viewBox' | 'formatter'> & ViewBox & {
+    formatter?: LabelListFormatter;
+    value?: string | number;
+    index: number;
+    key: string;
+};
+export interface LabelListSlots {
+    content?: (props: LabelListSlotProps) => VNodeChild;
+    label?: (props: LabelListSlotProps) => VNodeChild;
 }

package/dist/components/label/utils.d.ts

@@ -1,21 +1,33 @@
-import { CartesianViewBox, PolarViewBox, ViewBox } from '../../cartesian/type';
-import { LabelProps } from './types';
-import { Coordinate } from '../../types';
-export declare function parseViewBox(props: any): ViewBox | undefined;
-export declare function isPolar(viewBox: CartesianViewBox | PolarViewBox): viewBox is PolarViewBox;
-export declare const RADIAN: number;
-export declare function polarToCartesian(cx: number, cy: number, radius: number, angle: number): Coordinate;
+import { CartesianViewBoxRequired, PolarViewBoxRequired, ViewBox } from '../../types/viewBox.js';
+import { Data, LabelViewProps } from './types.js';
+export declare function parseViewBox(props: Data & {
+    angle?: number;
+    r?: number;
+    radius?: number;
+    top?: number;
+    left?: number;
+    labelViewBox?: ViewBox;
+    viewBox?: ViewBox;
+}): ViewBox | undefined;
+/** A label's box with every field set: missing sizes and angles are 0. */
+export type LabelViewBox = CartesianViewBoxRequired | PolarViewBoxRequired;
+/**
+ * Fills the fields a caller's `viewBox` leaves out, once, so position math never reads
+ * `undefined` and renders NaN. A box with a numeric `cx` is polar.
+ */
+export declare function normalizeViewBox(viewBox: ViewBox): LabelViewBox;
+export declare function isPolar(viewBox: LabelViewBox): viewBox is PolarViewBoxRequired;
 type PolarLabelPosition = 'insideStart' | 'insideEnd' | 'end';
-export declare function renderRadialLabel(labelProps: LabelProps, position: PolarLabelPosition, label: string | number | undefined, attrs: Record<string, any>, viewBox: PolarViewBox): import("vue/jsx-runtime").JSX.Element;
-export declare function getAttrsOfPolarLabel(props: LabelProps, viewBox?: PolarViewBox): {
+export declare function renderRadialLabel(labelProps: LabelViewProps, position: PolarLabelPosition, label: string | number | undefined, attrs: Record<string, unknown>, viewBox: PolarViewBoxRequired, generatedId: string): import("vue/jsx-runtime").JSX.Element;
+export declare function getAttrsOfPolarLabel(props: LabelViewProps, viewBox: PolarViewBoxRequired): {
     x: number;
     y: number;
     textAnchor: string;
     verticalAnchor: string;
 };
-export declare function getAttrsOfCartesianLabel(props: LabelProps, viewBox: CartesianViewBox): {
-    height?: number;
-    width?: number;
+export declare function getAttrsOfCartesianLabel(props: LabelViewProps, viewBox: CartesianViewBoxRequired): {
+    height?: number | undefined;
+    width?: number | undefined;
     x: number;
     y: number;
     textAnchor: string;

package/dist/components/legend/Legend.d.ts

@@ -1,4 +1,109 @@
-import { DefineSetupFnComponent, SlotsType } from 'vue';
-import { LegendPropsWithSVG, LegendSlots } from './type';
-declare const _default: DefineSetupFnComponent<LegendPropsWithSVG, {}, SlotsType<LegendSlots>>;
-export default _default;
+import { ExtractPropTypes, PropType, SlotsType } from 'vue';
+import { LegendHidden, LegendSlots } from './type.js';
+import { LegendPayload } from '../../types/legend.js';
+export type LegendBoundingBox = {
+    width: number;
+    height: number;
+} | null;
+declare const Legend: import('vue').DefineComponent<ExtractPropTypes<{
+    readonly hidden: PropType<LegendHidden>;
+    readonly layout: {
+        readonly type: PropType<import('../../types/index.js').LayoutType | "auto">;
+        readonly default: "auto";
+    };
+    readonly align: {
+        readonly type: PropType<import('../../types/legend.js').HorizontalAlignmentType>;
+        readonly default: "center";
+    };
+    readonly verticalAlign: {
+        readonly type: PropType<import('../../types/legend.js').VerticalAlignmentType>;
+        readonly default: "bottom";
+    };
+    readonly position: {
+        readonly type: PropType<import('../../cartesian/getCartesianPosition.js').CartesianPosition>;
+        readonly default: undefined;
+    };
+    readonly offset: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+    readonly width: NumberConstructor;
+    readonly height: NumberConstructor;
+    readonly iconSize: {
+        readonly type: NumberConstructor;
+        readonly default: 14;
+    };
+    readonly iconType: PropType<import('../../types/legend.js').LegendType>;
+    readonly wrapperStyle: PropType<import('vue').CSSProperties>;
+    readonly contentStyle: PropType<import('vue').CSSProperties>;
+    readonly itemStyle: PropType<import('vue').CSSProperties>;
+    readonly formatter: PropType<(value: string | undefined, entry: LegendPayload) => string>;
+    readonly payloadUniqBy: PropType<boolean | ((item: LegendPayload) => unknown)>;
+    readonly itemSorter: {
+        readonly type: PropType<"value" | "dataKey" | ((item: LegendPayload) => number | string)>;
+        readonly default: undefined;
+    };
+    readonly to: PropType<string | HTMLElement>;
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'update:hidden': (_hidden: LegendHidden) => boolean;
+    click: (_entry: LegendPayload, _index: number, _event: MouseEvent | KeyboardEvent) => boolean;
+    mouseenter: (_entry: LegendPayload, _index: number, _event: MouseEvent | KeyboardEvent) => boolean;
+    mouseleave: (_entry: LegendPayload, _index: number, _event: MouseEvent | KeyboardEvent) => boolean;
+    'bbox-update': (_box: LegendBoundingBox) => boolean;
+}, string, import('vue').PublicProps, Readonly<ExtractPropTypes<{
+    readonly hidden: PropType<LegendHidden>;
+    readonly layout: {
+        readonly type: PropType<import('../../types/index.js').LayoutType | "auto">;
+        readonly default: "auto";
+    };
+    readonly align: {
+        readonly type: PropType<import('../../types/legend.js').HorizontalAlignmentType>;
+        readonly default: "center";
+    };
+    readonly verticalAlign: {
+        readonly type: PropType<import('../../types/legend.js').VerticalAlignmentType>;
+        readonly default: "bottom";
+    };
+    readonly position: {
+        readonly type: PropType<import('../../cartesian/getCartesianPosition.js').CartesianPosition>;
+        readonly default: undefined;
+    };
+    readonly offset: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+    readonly width: NumberConstructor;
+    readonly height: NumberConstructor;
+    readonly iconSize: {
+        readonly type: NumberConstructor;
+        readonly default: 14;
+    };
+    readonly iconType: PropType<import('../../types/legend.js').LegendType>;
+    readonly wrapperStyle: PropType<import('vue').CSSProperties>;
+    readonly contentStyle: PropType<import('vue').CSSProperties>;
+    readonly itemStyle: PropType<import('vue').CSSProperties>;
+    readonly formatter: PropType<(value: string | undefined, entry: LegendPayload) => string>;
+    readonly payloadUniqBy: PropType<boolean | ((item: LegendPayload) => unknown)>;
+    readonly itemSorter: {
+        readonly type: PropType<"value" | "dataKey" | ((item: LegendPayload) => number | string)>;
+        readonly default: undefined;
+    };
+    readonly to: PropType<string | HTMLElement>;
+}>> & Readonly<{
+    onClick?: ((_entry: LegendPayload, _index: number, _event: KeyboardEvent | MouseEvent) => any) | undefined;
+    onMouseenter?: ((_entry: LegendPayload, _index: number, _event: KeyboardEvent | MouseEvent) => any) | undefined;
+    onMouseleave?: ((_entry: LegendPayload, _index: number, _event: KeyboardEvent | MouseEvent) => any) | undefined;
+    "onUpdate:hidden"?: ((_hidden: LegendHidden) => any) | undefined;
+    "onBbox-update"?: ((_box: LegendBoundingBox) => any) | undefined;
+}>, {
+    readonly offset: number;
+    readonly position: import('../../cartesian/getCartesianPosition.js').CartesianPosition;
+    readonly align: import('../../types/legend.js').HorizontalAlignmentType;
+    readonly verticalAlign: import('../../types/legend.js').VerticalAlignmentType;
+    readonly layout: "auto" | import('../../types/index.js').LayoutType;
+    readonly iconSize: number;
+    readonly itemSorter: "dataKey" | "value" | ((item: LegendPayload) => number | string);
+}, SlotsType<LegendSlots>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default Legend;

package/dist/components/legend/LegendSymbol.d.ts

@@ -1,6 +1,5 @@
 import { PropType } from 'vue';
-import { LegendType } from '../../types/legend';
-import { LegendPayload } from '../DefaultLegendContent';
+import { LegendPayload, LegendType } from '../../types/legend.js';
 export declare const SIZE = 32;
 export declare const LegendSymbol: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     type: PropType<LegendType>;
@@ -12,7 +11,7 @@ export declare const LegendSymbol: import('vue').DefineComponent<import('vue').E
     data: {
         type: PropType<LegendPayload>;
     };
-}>, () => 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<{
     type: PropType<LegendType>;
     color: StringConstructor;
     size: {

package/dist/components/legend/hooks/useLegend.d.ts

@@ -1,9 +1,9 @@
 import { CSSProperties } from 'vue';
-import { LayoutType } from '../../../types';
-import { LegendPayload } from '../../DefaultLegendContent';
-import { LegendProps } from '../type';
-export declare function useLegend(props: LegendProps): {
-    legendRef: import('vue').Ref<HTMLElement, HTMLElement>;
+import { LayoutType } from '../../../types/index.js';
+import { LegendPayload } from '../../../types/legend.js';
+import { LegendInput } from '../type.js';
+export declare function useLegend(props: LegendInput): {
+    legendRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
     boundingBox: import('vue').ComputedRef<{
         width: number;
         height: number;
@@ -11,12 +11,10 @@ export declare function useLegend(props: LegendProps): {
     widthOrHeight: import('vue').ComputedRef<{
         height?: number;
         width?: number;
-    }>;
+    } | null>;
     processedPayload: import('vue').ComputedRef<LegendPayload[]>;
     outerStyle: import('vue').ComputedRef<CSSProperties>;
-    legendPortal: import('vue').ComputedRef<HTMLElement>;
+    legendPortal: import('vue').ComputedRef<string | HTMLElement | null | undefined>;
     resolvedLayout: import('vue').ComputedRef<LayoutType>;
-    positionViewBox: import('vue').ComputedRef<Required<import('../../../cartesian/type').CartesianViewBox>>;
-    syncSettings: () => void;
-    syncSize: () => void;
+    positionViewBox: import('vue').ComputedRef<Required<import('../../../types/viewBox.js').CartesianViewBox> | null>;
 };

package/dist/components/legend/hooks/useLegendContent.d.ts

@@ -1,21 +1,17 @@
-import { CSSProperties, Component } from 'vue';
-import { LayoutType } from '../../../types';
-import { LegendType } from '../../../types/legend';
-import { HorizontalAlignmentType, LegendPayload, VerticalAlignmentType } from '../../DefaultLegendContent';
+import { CSSProperties, Component, VNodeChild } from 'vue';
+import { LayoutType } from '../../../types/index.js';
+import { HorizontalAlignmentType, LegendPayload, LegendType, VerticalAlignmentType } from '../../../types/legend.js';
 interface LegendContentProps {
-    layout?: LayoutType;
+    layout?: LayoutType | 'auto';
     align?: HorizontalAlignmentType;
     verticalAlign?: VerticalAlignmentType;
     iconSize?: number;
     iconType?: LegendType;
     wrapperStyle?: CSSProperties;
     contentStyle?: CSSProperties;
-    formatter?: (value: string, entry: LegendPayload) => string;
-    onClick?: (data: LegendPayload, index: number) => void;
-    onMouseEnter?: (data: LegendPayload, index: number) => void;
-    onMouseLeave?: (data: LegendPayload, index: number) => void;
+    formatter?: (value: string | undefined, entry: LegendPayload) => string;
     payload?: LegendPayload[];
-    content?: Component | ((props: any) => any);
+    content?: Component | ((props: LegendContentProps) => VNodeChild);
 }
 export declare function useLegendContent(props: LegendContentProps): {
     getWrapperStyle: (layout?: LayoutType, align?: HorizontalAlignmentType, verticalAlign?: VerticalAlignmentType) => CSSProperties;
@@ -28,9 +24,6 @@ export declare function useLegendContent(props: LegendContentProps): {
         height: number;
     };
     getSvgStyle: () => CSSProperties;
-    formatValue: (entry: LegendPayload) => string;
-    handleClick: (entry: LegendPayload, index: number) => void;
-    handleMouseEnter: (entry: LegendPayload, index: number) => void;
-    handleMouseLeave: (entry: LegendPayload, index: number) => void;
+    formatValue: (entry: LegendPayload) => string | undefined;
 };
 export {};

package/dist/components/legend/type.d.ts

@@ -1,13 +1,14 @@
-import { CSSProperties, PropType, VNode } from 'vue';
-import { LayoutType, Margin } from '../../types';
-import { CartesianPosition } from '../../cartesian/getCartesianPosition';
-import { LegendType } from '../../types/legend';
-import { HorizontalAlignmentType, LegendPayload, VerticalAlignmentType } from '../DefaultLegendContent';
-import { VuePropsToType, WithSVGProps } from '../../types/common';
+import { CSSProperties, PropType, VNodeChild } from 'vue';
+import { LayoutType } from '../../types/index.js';
+import { CartesianPosition } from '../../cartesian/getCartesianPosition.js';
+import { HorizontalAlignmentType, LegendPayload, LegendType, VerticalAlignmentType } from '../../types/legend.js';
+import { VuePropsToType } from '../../types/common.js';
 export interface LegendSlots {
-    content: (params: LegendContentProps) => VNode;
+    content?: (params: LegendContentProps) => VNodeChild;
 }
+export type LegendHidden = string[];
 export declare const LegendVueProps: {
+    readonly hidden: PropType<LegendHidden>;
     readonly layout: {
         readonly type: PropType<LayoutType | "auto">;
         readonly default: "auto";
@@ -26,7 +27,7 @@ export declare const LegendVueProps: {
      */
     readonly position: {
         readonly type: PropType<CartesianPosition>;
-        readonly default: any;
+        readonly default: undefined;
     };
     /**
      * The offset to the specified `position`. Direction of the offset depends on the position.
@@ -45,26 +46,17 @@ export declare const LegendVueProps: {
     readonly wrapperStyle: PropType<CSSProperties>;
     readonly contentStyle: PropType<CSSProperties>;
     readonly itemStyle: PropType<CSSProperties>;
-    readonly formatter: PropType<(value: string, entry: LegendPayload) => string>;
-    readonly onClick: PropType<(data: LegendPayload, index: number) => void>;
-    readonly onMouseEnter: PropType<(data: LegendPayload, index: number) => void>;
-    readonly onMouseLeave: PropType<(data: LegendPayload, index: number) => void>;
-    readonly margin: PropType<Margin>;
-    readonly chartWidth: NumberConstructor;
-    readonly chartHeight: NumberConstructor;
-    readonly payloadUniqBy: PropType<boolean | ((item: LegendPayload) => any)>;
+    readonly formatter: PropType<(value: string | undefined, entry: LegendPayload) => string>;
+    readonly payloadUniqBy: PropType<boolean | ((item: LegendPayload) => unknown)>;
+    /** Sort entries. By default they keep the order of the data (Pie) or of the series. */
     readonly itemSorter: {
         readonly type: PropType<"value" | "dataKey" | ((item: LegendPayload) => number | string)>;
-        readonly default: "value";
+        readonly default: undefined;
     };
-    readonly portal: PropType<HTMLElement | null>;
-    readonly onBBoxUpdate: PropType<(box: {
-        width: number;
-        height: number;
-    } | null) => void>;
+    readonly to: PropType<string | HTMLElement>;
 };
-export type LegendProps = VuePropsToType<typeof LegendVueProps>;
-export type LegendPropsWithSVG = WithSVGProps<typeof LegendVueProps>;
-export interface LegendContentProps extends LegendProps {
+/** Resolved Legend props inside the library; the public `LegendProps` is derived from the component. */
+export type LegendInput = VuePropsToType<typeof LegendVueProps>;
+export interface LegendContentProps extends LegendInput {
     payload: LegendPayload[];
 }

package/dist/components/legend/utils.d.ts

@@ -1,7 +1,7 @@
 import { CSSProperties } from 'vue';
-import { LayoutType, Margin } from '../../types';
-import { CartesianPosition } from '../../cartesian/getCartesianPosition';
-import { HorizontalAlignmentType, VerticalAlignmentType } from '../DefaultLegendContent';
+import { LayoutType, Margin } from '../../types/index.js';
+import { CartesianPosition } from '../../cartesian/getCartesianPosition.js';
+import { HorizontalAlignmentType, VerticalAlignmentType } from '../../types/legend.js';
 type PositionInput = {
     layout?: LayoutType;
     align?: HorizontalAlignmentType;
@@ -23,5 +23,5 @@ export declare function getWidthOrHeight(layout: LayoutType | undefined, height:
     height?: number;
     width?: number;
 };
-export declare function defaultUniqBy(entry: any): any;
+export declare function defaultUniqBy(entry: import('../../types/legend.js').LegendPayload): string | undefined;
 export {};

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

@@ -0,0 +1,19 @@
+import { PropType, VNodeChild } from 'vue';
+import { TooltipPayload } from '../../types/tooltip.js';
+import { ChartCoordinate } from '../../types/index.js';
+import { CursorSlotProps } from './types.js';
+export declare const Cursor: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    cursor: (ObjectConstructor | BooleanConstructor)[];
+    cursorSlot: PropType<(props: CursorSlotProps) => VNodeChild>;
+    tooltipEventType: StringConstructor;
+    coordinate: PropType<ChartCoordinate>;
+    payload: PropType<TooltipPayload>;
+    index: NumberConstructor;
+}>, () => VNodeChild, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    cursor: (ObjectConstructor | BooleanConstructor)[];
+    cursorSlot: PropType<(props: CursorSlotProps) => VNodeChild>;
+    tooltipEventType: StringConstructor;
+    coordinate: PropType<ChartCoordinate>;
+    payload: PropType<TooltipPayload>;
+    index: NumberConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,35 @@
+import { PropType, VNodeChild } from 'vue';
+import { Formatter, TooltipPayload } from '../../types/tooltip.js';
+import { NameType, Payload, ValueType } from '../../types/index.js';
+export declare const DefaultTooltipContent: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    label: (StringConstructor | NumberConstructor)[];
+    payload: PropType<TooltipPayload>;
+    active: BooleanConstructor;
+    separator: {
+        type: StringConstructor;
+        default: string;
+    };
+    contentStyle: ObjectConstructor;
+    labelStyle: ObjectConstructor;
+    itemStyle: ObjectConstructor;
+    itemSorter: PropType<((item: Payload<ValueType, NameType>) => number | string) | "dataKey" | "value" | "name">;
+    formatter: PropType<Formatter<ValueType, NameType>>;
+    labelFormatter: PropType<(label: string | number | undefined, payload: TooltipPayload) => VNodeChild>;
+}>, () => import("vue/jsx-runtime").JSX.Element | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    label: (StringConstructor | NumberConstructor)[];
+    payload: PropType<TooltipPayload>;
+    active: BooleanConstructor;
+    separator: {
+        type: StringConstructor;
+        default: string;
+    };
+    contentStyle: ObjectConstructor;
+    labelStyle: ObjectConstructor;
+    itemStyle: ObjectConstructor;
+    itemSorter: PropType<((item: Payload<ValueType, NameType>) => number | string) | "dataKey" | "value" | "name">;
+    formatter: PropType<Formatter<ValueType, NameType>>;
+    labelFormatter: PropType<(label: string | number | undefined, payload: TooltipPayload) => VNodeChild>;
+}>> & Readonly<{}>, {
+    active: boolean;
+    separator: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;