vccs 0.5.0 → 1.0.0-beta.1

package/dist/cartesian/line/Line.d.ts

@@ -1,81 +1,181 @@
-import { SlotsType } from 'vue';
-import { ActivePointsSlots } from './ActivePoints';
-export declare const Line: import('vue').DefineComponent<{
-    activeDot?: any;
-    animateNewValues?: boolean;
-    animationId?: string;
-    class?: import('../../types').VueClassValue;
-    connectNulls?: boolean;
-    data?: any[];
-    dataKey: import('../../types').DataKey<any>;
-    dot?: any;
-    hide?: boolean;
-    id?: string;
-    isAnimationActive?: boolean;
-    label?: any;
-    legendType?: import('../../types/legend').LegendType;
-    layout?: import('../../types').LayoutType;
-    name?: string | number;
-    onAnimationEnd?: () => void;
-    onAnimationStart?: () => void;
-    stroke?: string;
-    strokeWidth?: number;
-    tooltipType?: import('../../types').TooltipType;
-    transition?: import('motion-v').AnimationOptions;
-    type?: import('../..').CurveType;
-    unit?: string | number;
-    xAxisId?: import('../../types/axis').AxisId;
-    yAxisId?: import('../../types/axis').AxisId;
-    needClip?: boolean;
-}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
-    activeDot?: any;
-    animateNewValues?: boolean;
-    animationId?: string;
-    class?: import('../../types').VueClassValue;
-    connectNulls?: boolean;
-    data?: any[];
-    dataKey: import('../../types').DataKey<any>;
-    dot?: any;
-    hide?: boolean;
-    id?: string;
-    isAnimationActive?: boolean;
-    label?: any;
-    legendType?: import('../../types/legend').LegendType;
-    layout?: import('../../types').LayoutType;
-    name?: string | number;
-    onAnimationEnd?: () => void;
-    onAnimationStart?: () => void;
-    stroke?: string;
-    strokeWidth?: number;
-    tooltipType?: import('../../types').TooltipType;
-    transition?: import('motion-v').AnimationOptions;
-    type?: import('../..').CurveType;
-    unit?: string | number;
-    xAxisId?: import('../../types/axis').AxisId;
-    yAxisId?: import('../../types/axis').AxisId;
-    needClip?: boolean;
-}> & Readonly<{}>, {
-    top: number;
-    left: number;
-    width: number;
-    height: number;
-    yAxisId: import('../../types/axis').AxisId;
-    xAxisId: import('../../types/axis').AxisId;
-    class: import('../../types').VueClassValue;
+import { PropType, SlotsType } from 'vue';
+import { LineSlots } from './type.js';
+export declare const Line: import('../../utils/attributes.js').WithAttributes<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    activeDot: {
+        type: PropType<boolean | Record<string, unknown>>;
+        default: boolean;
+    };
+    isAnimationActive: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    connectNulls: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    data: {
+        type: ArrayConstructor;
+        default: undefined;
+    };
+    dataKey: {
+        type: PropType<import('../../types/base.js').ChartDataKey>;
+        required: true;
+    };
+    dot: {
+        type: PropType<boolean | Record<string, unknown>>;
+        default: boolean;
+    };
+    hide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: (ObjectConstructor | BooleanConstructor)[];
+    };
+    legendType: {
+        type: PropType<import('../../types/legend.js').LegendType>;
+        default: string;
+    };
+    stroke: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    strokeWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    tooltipType: {
+        type: PropType<import('../../types/index.js').TooltipType>;
+    };
+    transition: {
+        type: PropType<import('motion-v').ValueAnimationTransition<number>>;
+        default: undefined;
+    };
+    type: {
+        type: PropType<import('../../index.js').CurveType | import('d3-shape').CurveFactory>;
+    };
+    unit: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    xAxisId: {
+        type: PropType<import('../../types/axis.js').AxisId>;
+        default: number;
+    };
+    yAxisId: {
+        type: PropType<import('../../types/axis.js').AxisId>;
+        default: number;
+    };
+    id: {
+        type: StringConstructor;
+    };
+    name: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    class: {
+        type: PropType<import('../../types/index.js').VueClassValue>;
+        default: undefined;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (_entry: import('../../index.js').LinePointItem, _index: number, _event: MouseEvent) => boolean;
+    mouseenter: (_entry: import('../../index.js').LinePointItem, _index: number, _event: MouseEvent) => boolean;
+    mouseleave: (_entry: import('../../index.js').LinePointItem, _index: number, _event: MouseEvent) => boolean;
+    'animation-start': () => boolean;
+    'animation-end': () => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    activeDot: {
+        type: PropType<boolean | Record<string, unknown>>;
+        default: boolean;
+    };
+    isAnimationActive: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    connectNulls: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    data: {
+        type: ArrayConstructor;
+        default: undefined;
+    };
+    dataKey: {
+        type: PropType<import('../../types/base.js').ChartDataKey>;
+        required: true;
+    };
+    dot: {
+        type: PropType<boolean | Record<string, unknown>>;
+        default: boolean;
+    };
+    hide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: (ObjectConstructor | BooleanConstructor)[];
+    };
+    legendType: {
+        type: PropType<import('../../types/legend.js').LegendType>;
+        default: string;
+    };
+    stroke: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    strokeWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    tooltipType: {
+        type: PropType<import('../../types/index.js').TooltipType>;
+    };
+    transition: {
+        type: PropType<import('motion-v').ValueAnimationTransition<number>>;
+        default: undefined;
+    };
+    type: {
+        type: PropType<import('../../index.js').CurveType | import('d3-shape').CurveFactory>;
+    };
+    unit: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    xAxisId: {
+        type: PropType<import('../../types/axis.js').AxisId>;
+        default: number;
+    };
+    yAxisId: {
+        type: PropType<import('../../types/axis.js').AxisId>;
+        default: number;
+    };
+    id: {
+        type: StringConstructor;
+    };
+    name: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    class: {
+        type: PropType<import('../../types/index.js').VueClassValue>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onClick?: ((_entry: import('../../index.js').LinePointItem, _index: number, _event: MouseEvent) => any) | undefined;
+    onMouseenter?: ((_entry: import('../../index.js').LinePointItem, _index: number, _event: MouseEvent) => any) | undefined;
+    onMouseleave?: ((_entry: import('../../index.js').LinePointItem, _index: number, _event: MouseEvent) => any) | undefined;
+    "onAnimation-start"?: (() => any) | undefined;
+    "onAnimation-end"?: (() => any) | undefined;
+}>, {
+    hide: boolean;
     stroke: string;
     strokeWidth: number;
-    transition: import('motion-v').AnimationOptions;
+    class: import('../../types/index.js').VueClassValue;
+    xAxisId: import('../../types/axis.js').AxisId;
+    yAxisId: import('../../types/axis.js').AxisId;
     data: unknown[];
-    connectNulls: boolean;
-    hide: boolean;
-    legendType: import('../../types/legend').LegendType;
     isAnimationActive: boolean;
-    needClip: boolean;
-    activeDot: boolean | Function | Record<string, any>;
-    dot: boolean | Function | Record<string, any>;
-}, SlotsType<ActivePointsSlots & {
-    default?: () => any;
-    shape?: (props: any) => any;
-    dot?: (props: any) => any;
-    label?: (props: any) => any;
-}>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    transition: import('motion-v').ValueAnimationTransition<number>;
+    connectNulls: boolean;
+    activeDot: boolean | Record<string, unknown>;
+    dot: boolean | Record<string, unknown>;
+    legendType: import('../../types/legend.js').LegendType;
+}, SlotsType<LineSlots>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, import('../../utils/attributes.js').SvgTemplateAttributes>;

package/dist/cartesian/line/StaticLine.d.ts

@@ -1,16 +1 @@
-import { PropType } from 'vue';
-import { Point } from '../../shape/Curve';
-export declare const Dots: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
-    points: {
-        type: PropType<ReadonlyArray<Point>>;
-        default: () => any[];
-    };
-}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
-    points: {
-        type: PropType<ReadonlyArray<Point>>;
-        default: () => any[];
-    };
-}>> & Readonly<{}>, {
-    points: readonly Point[];
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export declare const StaticLine: import('vue').DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/cartesian/line/hooks/useLine.d.ts

@@ -1,28 +1,27 @@
-import { LinePointItem, LinePropsInternal } from '../type';
-import { ComputedRef, InjectionKey, Ref, SVGAttributes, ShallowRef } from 'vue';
+import { LineInput, LineSlots } from '../type.js';
+import { LinePointItem } from '../../../types/line.js';
+import { ComputedRef, Ref, SVGAttributes, ShallowRef } from 'vue';
 export interface LineContext {
     clipPathId: Ref<string>;
     layout: Readonly<Ref<string>>;
     points: Ref<ReadonlyArray<LinePointItem> | undefined>;
-    props: LinePropsInternal;
+    props: LineInput;
     attrs: SVGAttributes;
     lineData: Readonly<ShallowRef<ReadonlyArray<LinePointItem> | undefined>>;
-    isAnimating: Ref<boolean>;
     needClip: ComputedRef<boolean>;
-    dot: any;
-    clipDot: boolean;
-    dotSize: number;
-    shapeSlot?: (props: any) => any;
-    dotSlot?: (props: any) => any;
-    labelSlot?: (props: any) => any;
+    clipDot: ComputedRef<boolean>;
+    shapeSlot?: LineSlots['shape'];
+    dotSlot?: LineSlots['dot'];
+    labelSlot?: LineSlots['label'];
+    /** The labels as drawn on this frame; LabelList children read them. */
+    labelData: ShallowRef<ComputedRef<readonly import('../../../components/label/types.js').Data[]> | undefined>;
 }
-export declare const LineContextKey: InjectionKey<LineContext>;
-export declare function provideLineContext(context: LineContext): void;
 export declare function useLineContext(): LineContext;
-export declare function useLine(props: LinePropsInternal, attrs?: SVGAttributes, shapeSlot?: (props: any) => any, dotSlot?: (props: any) => any, labelSlot?: (props: any) => any): {
+export declare function useLine(props: LineInput, attrs?: SVGAttributes, shapeSlot?: LineSlots['shape'], dotSlot?: LineSlots['dot'], labelSlot?: LineSlots['label']): {
     shouldRender: ComputedRef<boolean>;
     needClip: ComputedRef<boolean>;
-    lineData: Readonly<ShallowRef<readonly LinePointItem[]>>;
-    points: Ref<readonly LinePointItem[], readonly LinePointItem[]>;
+    lineData: ComputedRef<readonly LinePointItem[] | undefined>;
+    points: Ref<readonly LinePointItem[] | undefined, readonly LinePointItem[] | undefined>;
     clipPathId: ComputedRef<string>;
+    labelData: ComputedRef<readonly import('../../../components/label/types.js').Data[] | undefined>;
 };

package/dist/cartesian/line/type.d.ts

@@ -1,53 +1,21 @@
-import { DataKey, LayoutType, TooltipType, VueClassValue, VuePropsToType, WithSVGProps } from '../../types';
-import { AxisId } from '../../types/axis';
-import { AnimationOptions } from 'motion-v';
-import { LegendType } from '../../types/legend';
-import { CurveFactory } from 'victory-vendor/d3-shape';
-import { CurveType, Point } from '../../shape/Curve';
-import { PropType } from 'vue';
-export interface LinePointItem extends Point {
-    readonly value?: number;
-    readonly payload?: any;
-}
-export interface LineProps {
-    activeDot?: any;
-    animateNewValues?: boolean;
-    animationId?: string;
-    class?: VueClassValue;
-    connectNulls?: boolean;
-    data?: any[];
-    dataKey: DataKey<any>;
-    dot?: any;
-    hide?: boolean;
-    id?: string;
-    isAnimationActive?: boolean;
-    label?: any;
-    legendType?: LegendType;
-    layout?: LayoutType;
-    name?: string | number;
-    onAnimationEnd?: () => void;
-    onAnimationStart?: () => void;
-    stroke?: string;
-    strokeWidth?: number;
-    tooltipType?: TooltipType;
-    transition?: AnimationOptions;
-    type?: CurveType;
-    unit?: string | number;
-    xAxisId?: AxisId;
-    yAxisId?: AxisId;
-    needClip?: boolean;
-}
+import { LinePointItem } from '../../types/line.js';
+import { LabelListSlotProps } from '../../components/label/types.js';
+import { ExtractPropTypes, PropType, VNode, VNodeChild } from 'vue';
+import { ChartDataKey } from '../../types/base.js';
+import { TooltipType } from '../../types/index.js';
+import { AxisId } from '../../types/axis.js';
+import { ValueAnimationTransition } from 'motion-v';
+import { LegendType } from '../../types/legend.js';
+import { CurveFactory } from 'd3-shape';
+import { CurveType } from '../../shape/Curve.js';
 export declare const LineVueProps: {
     activeDot: {
-        type: (ObjectConstructor | FunctionConstructor | BooleanConstructor)[];
+        type: PropType<boolean | Record<string, unknown>>;
         default: boolean;
     };
-    animationId: {
-        type: StringConstructor;
-    };
     isAnimationActive: {
         type: BooleanConstructor;
-        default: boolean;
+        default: undefined;
     };
     connectNulls: {
         type: BooleanConstructor;
@@ -55,14 +23,14 @@ export declare const LineVueProps: {
     };
     data: {
         type: ArrayConstructor;
-        default: any;
+        default: undefined;
     };
     dataKey: {
-        type: PropType<DataKey<any>>;
-        required: boolean;
+        type: PropType<ChartDataKey>;
+        required: true;
     };
     dot: {
-        type: (ObjectConstructor | FunctionConstructor | BooleanConstructor)[];
+        type: PropType<boolean | Record<string, unknown>>;
         default: boolean;
     };
     hide: {
@@ -76,15 +44,9 @@ export declare const LineVueProps: {
         type: PropType<LegendType>;
         default: string;
     };
-    onAnimationEnd: {
-        type: FunctionConstructor;
-    };
-    onAnimationStart: {
-        type: FunctionConstructor;
-    };
     stroke: {
         type: StringConstructor;
-        default: string;
+        default: undefined;
     };
     strokeWidth: {
         type: NumberConstructor;
@@ -94,17 +56,14 @@ export declare const LineVueProps: {
         type: PropType<TooltipType>;
     };
     transition: {
-        type: PropType<AnimationOptions>;
-        default: () => {
-            duration: number;
-            ease: string;
-        };
+        type: PropType<ValueAnimationTransition<number>>;
+        default: undefined;
     };
     type: {
         type: PropType<CurveType | CurveFactory>;
     };
     unit: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: (StringConstructor | NumberConstructor)[];
     };
     xAxisId: {
         type: PropType<AxisId>;
@@ -114,54 +73,43 @@ export declare const LineVueProps: {
         type: PropType<AxisId>;
         default: number;
     };
-    needClip: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
     id: {
         type: StringConstructor;
     };
-    activeIndex: {
-        type: NumberConstructor;
-    };
-    activePoint: {
-        type: ObjectConstructor;
-    };
-    left: {
-        type: NumberConstructor;
-        default: number;
-    };
-    top: {
-        type: NumberConstructor;
-        default: number;
-    };
-    width: {
-        type: NumberConstructor;
-        default: number;
-    };
-    height: {
-        type: NumberConstructor;
-        default: number;
-    };
     name: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: (StringConstructor | NumberConstructor)[];
     };
     class: {
-        type: PropType<VueClassValue>;
-        default: any;
-    };
-    layout: {
-        type: PropType<LayoutType>;
-    };
-    baseLine: {
-        type: PropType<number | ReadonlyArray<Point>>;
-    };
-    points: {
-        type: PropType<ReadonlyArray<Point>>;
-    };
-    path: {
-        type: StringConstructor;
+        type: PropType<import('../../types/index.js').VueClassValue>;
+        default: undefined;
     };
 };
-export type LinePropsInternal = VuePropsToType<typeof LineVueProps>;
-export type LinePropsWithSVG = WithSVGProps<typeof LineVueProps>;
+export type LineInput = ExtractPropTypes<typeof LineVueProps>;
+type ActivePointSlotProps = {
+    'index': number;
+    'dataKey': ChartDataKey;
+    'cx': number;
+    'cy': number;
+    'r': number;
+    'fill': string;
+    'stroke-width': number;
+    'stroke': string;
+    'payload': LinePointItem['payload'];
+    'value'?: number;
+};
+type ActivePointsSlots = {
+    activeDot?: (props: ActivePointSlotProps) => VNodeChild;
+};
+export type LineSlots = ActivePointsSlots & {
+    default?: () => VNode[];
+    shape?: (props: import('../../shape/Curve.js').CurveInput) => VNodeChild;
+    dot?: (props: {
+        cx: number;
+        cy: number;
+        index: number;
+        value?: number;
+        payload?: unknown;
+    }) => VNodeChild;
+    label?: (props: LabelListSlotProps) => VNodeChild;
+};
+export {};