vccs 0.6.0 → 1.0.0-beta.2

package/dist/cartesian/cartesian-axis/CartesianAxis.d.ts

@@ -1,38 +1,13 @@
-import { CartesianViewBox } from '../type';
-import { VueClassValue } from '../../types/common';
-import { AxisInterval } from '../../types/axis';
-import { RechartsScale } from '../../types/scale';
-import { CartesianTickItem } from '../../types/tick';
+import { CartesianViewBoxRequired } from '../../types/viewBox.js';
+import { AxisInterval } from '../../types/axis.js';
+import { RechartsScale } from '../../types/scale.js';
+import { CartesianTickItem, TickFormatter } from '../../types/tick.js';
 import { PropType, SVGAttributes } from 'vue';
 /** The orientation of the axis in correspondence to the chart */
 export type Orientation = 'top' | 'bottom' | 'left' | 'right';
 /** A unit to be appended to a value */
 export type Unit = string | number;
-/** The formatter function of tick */
-export type TickFormatter = (value: any, index: number) => string;
-export interface CartesianAxisProps {
-    class?: VueClassValue;
-    x?: number;
-    y?: number;
-    width?: number;
-    height?: number;
-    unit?: Unit;
-    orientation?: Orientation;
-    viewBox?: CartesianViewBox;
-    mirror?: boolean;
-    tickMargin?: number;
-    hide?: boolean;
-    label?: any;
-    minTickGap?: number;
-    ticks?: ReadonlyArray<CartesianTickItem>;
-    tickSize?: number;
-    tickFormatter?: TickFormatter;
-    interval?: AxisInterval;
-    angle?: number;
-    scale: RechartsScale;
-    axisLine?: boolean | SVGAttributes;
-}
-export declare const CartesianAxis: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+export declare const CartesianAxis: import('../../utils/attributes.js').WithAttributes<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     x: {
         type: NumberConstructor;
         default: number;
@@ -49,13 +24,13 @@ export declare const CartesianAxis: import('vue').DefineComponent<import('vue').
         type: NumberConstructor;
         default: number;
     };
-    unit: (NumberConstructor | StringConstructor)[];
+    unit: (StringConstructor | NumberConstructor)[];
     orientation: {
-        type: StringConstructor;
+        type: PropType<Orientation>;
         default: string;
     };
     viewBox: {
-        type: ObjectConstructor;
+        type: PropType<CartesianViewBoxRequired>;
         default: () => {
             x: number;
             y: number;
@@ -64,7 +39,7 @@ export declare const CartesianAxis: import('vue').DefineComponent<import('vue').
         };
     };
     tick: {
-        type: BooleanConstructor;
+        type: PropType<boolean | SVGAttributes>;
         default: boolean;
     };
     axisLine: {
@@ -84,22 +59,22 @@ export declare const CartesianAxis: import('vue').DefineComponent<import('vue').
         default: number;
     };
     hide: BooleanConstructor;
-    label: any;
+    label: null;
     minTickGap: {
         type: NumberConstructor;
         default: number;
     };
     ticks: {
         type: PropType<ReadonlyArray<CartesianTickItem>>;
-        default: () => any[];
+        default: () => never[];
     };
     tickSize: {
         type: NumberConstructor;
         default: number;
     };
-    tickFormatter: FunctionConstructor;
+    tickFormatter: PropType<TickFormatter>;
     interval: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: PropType<AxisInterval>;
         default: string;
     };
     angle: NumberConstructor;
@@ -113,9 +88,9 @@ export declare const CartesianAxis: import('vue').DefineComponent<import('vue').
     /** Additional props to spread to each tick Text element. */
     tickTextProps: {
         type: ObjectConstructor;
-        default: any;
+        default: undefined;
     };
-}>, () => 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<{
     x: {
         type: NumberConstructor;
         default: number;
@@ -132,13 +107,13 @@ export declare const CartesianAxis: import('vue').DefineComponent<import('vue').
         type: NumberConstructor;
         default: number;
     };
-    unit: (NumberConstructor | StringConstructor)[];
+    unit: (StringConstructor | NumberConstructor)[];
     orientation: {
-        type: StringConstructor;
+        type: PropType<Orientation>;
         default: string;
     };
     viewBox: {
-        type: ObjectConstructor;
+        type: PropType<CartesianViewBoxRequired>;
         default: () => {
             x: number;
             y: number;
@@ -147,7 +122,7 @@ export declare const CartesianAxis: import('vue').DefineComponent<import('vue').
         };
     };
     tick: {
-        type: BooleanConstructor;
+        type: PropType<boolean | SVGAttributes>;
         default: boolean;
     };
     axisLine: {
@@ -167,22 +142,22 @@ export declare const CartesianAxis: import('vue').DefineComponent<import('vue').
         default: number;
     };
     hide: BooleanConstructor;
-    label: any;
+    label: null;
     minTickGap: {
         type: NumberConstructor;
         default: number;
     };
     ticks: {
         type: PropType<ReadonlyArray<CartesianTickItem>>;
-        default: () => any[];
+        default: () => never[];
     };
     tickSize: {
         type: NumberConstructor;
         default: number;
     };
-    tickFormatter: FunctionConstructor;
+    tickFormatter: PropType<TickFormatter>;
     interval: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: PropType<AxisInterval>;
         default: string;
     };
     angle: NumberConstructor;
@@ -196,26 +171,25 @@ export declare const CartesianAxis: import('vue').DefineComponent<import('vue').
     /** Additional props to spread to each tick Text element. */
     tickTextProps: {
         type: ObjectConstructor;
-        default: any;
+        default: undefined;
     };
 }>> & Readonly<{}>, {
-    interval: string | number;
-    tick: boolean;
-    width: number;
-    height: number;
-    x: number;
-    y: number;
-    viewBox: Record<string, any>;
-    orientation: string;
-    stroke: string;
-    label: any;
+    interval: AxisInterval;
+    tick: boolean | SVGAttributes;
     ticks: readonly CartesianTickItem[];
-    hide: boolean;
     mirror: boolean;
     minTickGap: number;
-    axisLine: boolean;
+    hide: boolean;
+    height: number;
+    orientation: Orientation;
+    width: number;
+    stroke: string;
+    viewBox: Required<import('../../types/viewBox.js').CartesianViewBox>;
+    x: number;
+    y: number;
+    axisLine: boolean | SVGAttributes;
     tickLine: boolean | Record<string, any>;
-    tickSize: number;
     tickMargin: number;
+    tickSize: number;
     tickTextProps: Record<string, any>;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, import('../../utils/attributes.js').SvgTemplateAttributes>;

package/dist/cartesian/cartesian-grid/Background.d.ts

@@ -6,7 +6,7 @@ declare const Background: import('vue').DefineComponent<import('vue').ExtractPro
     width: NumberConstructor;
     height: NumberConstructor;
     ry: NumberConstructor;
-}>, () => 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<{
     fill: StringConstructor;
     fillOpacity: NumberConstructor;
     x: NumberConstructor;

package/dist/cartesian/cartesian-grid/CartesianGrid.d.ts

@@ -1,10 +1,12 @@
-export declare const CartesianGrid: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+import { ExtractPropTypes, PropType, SlotsType } from 'vue';
+import { CartesianGridProps, CartesianGridSlots } from './type.js';
+export declare const CartesianGrid: import('../../utils/attributes.js').WithAttributes<import('vue').DefineComponent<ExtractPropTypes<{
     xAxisId: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: (StringConstructor | NumberConstructor)[];
         default: number;
     };
     yAxisId: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: (StringConstructor | NumberConstructor)[];
         default: number;
     };
     x: NumberConstructor;
@@ -13,7 +15,7 @@ export declare const CartesianGrid: import('vue').DefineComponent<import('vue').
     height: NumberConstructor;
     syncWithTicks: {
         type: BooleanConstructor;
-        default: any;
+        default: undefined;
     };
     horizontal: {
         type: (ObjectConstructor | BooleanConstructor)[];
@@ -23,22 +25,45 @@ export declare const CartesianGrid: import('vue').DefineComponent<import('vue').
         type: (ObjectConstructor | BooleanConstructor)[];
         default: boolean;
     };
-    horizontalPoints: ArrayConstructor;
-    verticalPoints: ArrayConstructor;
+    horizontalPoints: {
+        type: PropType<number[]>;
+        default: () => never[];
+    };
+    verticalPoints: {
+        type: PropType<number[]>;
+        default: () => never[];
+    };
     horizontalValues: ArrayConstructor;
     verticalValues: ArrayConstructor;
-    fill: StringConstructor;
+    stroke: {
+        type: PropType<CartesianGridProps["stroke"]>;
+        default: string;
+    };
+    fill: {
+        type: StringConstructor;
+        default: string;
+    };
+    verticalFill: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    horizontalFill: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
     fillOpacity: NumberConstructor;
     ry: NumberConstructor;
     verticalCoordinatesGenerator: FunctionConstructor;
     horizontalCoordinatesGenerator: FunctionConstructor;
-}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ExtractPropTypes<{
     xAxisId: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: (StringConstructor | NumberConstructor)[];
         default: number;
     };
     yAxisId: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: (StringConstructor | NumberConstructor)[];
         default: number;
     };
     x: NumberConstructor;
@@ -47,7 +72,7 @@ export declare const CartesianGrid: import('vue').DefineComponent<import('vue').
     height: NumberConstructor;
     syncWithTicks: {
         type: BooleanConstructor;
-        default: any;
+        default: undefined;
     };
     horizontal: {
         type: (ObjectConstructor | BooleanConstructor)[];
@@ -57,19 +82,46 @@ export declare const CartesianGrid: import('vue').DefineComponent<import('vue').
         type: (ObjectConstructor | BooleanConstructor)[];
         default: boolean;
     };
-    horizontalPoints: ArrayConstructor;
-    verticalPoints: ArrayConstructor;
+    horizontalPoints: {
+        type: PropType<number[]>;
+        default: () => never[];
+    };
+    verticalPoints: {
+        type: PropType<number[]>;
+        default: () => never[];
+    };
     horizontalValues: ArrayConstructor;
     verticalValues: ArrayConstructor;
-    fill: StringConstructor;
+    stroke: {
+        type: PropType<CartesianGridProps["stroke"]>;
+        default: string;
+    };
+    fill: {
+        type: StringConstructor;
+        default: string;
+    };
+    verticalFill: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    horizontalFill: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
     fillOpacity: NumberConstructor;
     ry: NumberConstructor;
     verticalCoordinatesGenerator: FunctionConstructor;
     horizontalCoordinatesGenerator: FunctionConstructor;
 }>> & Readonly<{}>, {
+    fill: string;
+    stroke: string | undefined;
     horizontal: boolean | Record<string, any>;
     vertical: boolean | Record<string, any>;
-    yAxisId: string | number;
     xAxisId: string | number;
+    yAxisId: string | number;
+    horizontalPoints: number[];
+    verticalPoints: number[];
+    verticalFill: string[];
+    horizontalFill: string[];
     syncWithTicks: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, SlotsType<CartesianGridSlots>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, import('../../utils/attributes.js').SvgTemplateAttributes>;

package/dist/cartesian/cartesian-grid/HorizontalGridLines.d.ts

@@ -1,37 +1,44 @@
+import { PropType, SlotsType } from 'vue';
+import { CartesianGridSlots } from './type.js';
+import { ChartOffset } from '../../types/index.js';
 declare const HorizontalGridLines: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     x: NumberConstructor;
     width: NumberConstructor;
     horizontal: (ObjectConstructor | BooleanConstructor)[];
-    horizontalPoints: ArrayConstructor;
+    horizontalPoints: PropType<number[]>;
+    /** Per-line opacity while lines fade in or out with their ticks. */
+    pointOpacity: PropType<number[]>;
     xAxisId: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: (StringConstructor | NumberConstructor)[];
         default: number;
     };
     yAxisId: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: (StringConstructor | NumberConstructor)[];
         default: number;
     };
-    offset: ObjectConstructor;
+    offset: PropType<ChartOffset>;
     xAxis: ObjectConstructor;
     yAxis: ObjectConstructor;
-}>, () => 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<{
     x: NumberConstructor;
     width: NumberConstructor;
     horizontal: (ObjectConstructor | BooleanConstructor)[];
-    horizontalPoints: ArrayConstructor;
+    horizontalPoints: PropType<number[]>;
+    /** Per-line opacity while lines fade in or out with their ticks. */
+    pointOpacity: PropType<number[]>;
     xAxisId: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: (StringConstructor | NumberConstructor)[];
         default: number;
     };
     yAxisId: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: (StringConstructor | NumberConstructor)[];
         default: number;
     };
-    offset: ObjectConstructor;
+    offset: PropType<ChartOffset>;
     xAxis: ObjectConstructor;
     yAxis: ObjectConstructor;
 }>> & Readonly<{}>, {
-    yAxisId: string | number;
     xAxisId: string | number;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    yAxisId: string | number;
+}, SlotsType<CartesianGridSlots>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default HorizontalGridLines;

package/dist/cartesian/cartesian-grid/HorizontalStripes.d.ts

@@ -1,20 +1,21 @@
+import { PropType } from 'vue';
 declare const HorizontalStripes: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
-    horizontalFill: ArrayConstructor;
+    horizontalFill: PropType<string[]>;
     fillOpacity: NumberConstructor;
     x: NumberConstructor;
     y: NumberConstructor;
     width: NumberConstructor;
     height: NumberConstructor;
-    horizontalPoints: ArrayConstructor;
+    horizontalPoints: PropType<number[]>;
     horizontal: (ObjectConstructor | BooleanConstructor)[];
-}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
-    horizontalFill: ArrayConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    horizontalFill: PropType<string[]>;
     fillOpacity: NumberConstructor;
     x: NumberConstructor;
     y: NumberConstructor;
     width: NumberConstructor;
     height: NumberConstructor;
-    horizontalPoints: ArrayConstructor;
+    horizontalPoints: PropType<number[]>;
     horizontal: (ObjectConstructor | BooleanConstructor)[];
 }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default HorizontalStripes;

package/dist/cartesian/cartesian-grid/VerticalGridLines.d.ts

@@ -1,26 +1,33 @@
+import { PropType, SlotsType } from 'vue';
+import { CartesianGridSlots } from './type.js';
+import { ChartOffset } from '../../types/index.js';
 declare const VerticalGridLines: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     x: NumberConstructor;
     y: NumberConstructor;
     width: NumberConstructor;
     height: NumberConstructor;
-    verticalPoints: ArrayConstructor;
-    xAxisId: (NumberConstructor | StringConstructor)[];
-    yAxisId: (NumberConstructor | StringConstructor)[];
-    offset: ObjectConstructor;
+    verticalPoints: PropType<number[]>;
+    /** Per-line opacity while lines fade in or out with their ticks. */
+    pointOpacity: PropType<number[]>;
+    xAxisId: (StringConstructor | NumberConstructor)[];
+    yAxisId: (StringConstructor | NumberConstructor)[];
+    offset: PropType<ChartOffset>;
     xAxis: ObjectConstructor;
     yAxis: ObjectConstructor;
     vertical: (ObjectConstructor | BooleanConstructor)[];
-}>, () => 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<{
     x: NumberConstructor;
     y: NumberConstructor;
     width: NumberConstructor;
     height: NumberConstructor;
-    verticalPoints: ArrayConstructor;
-    xAxisId: (NumberConstructor | StringConstructor)[];
-    yAxisId: (NumberConstructor | StringConstructor)[];
-    offset: ObjectConstructor;
+    verticalPoints: PropType<number[]>;
+    /** Per-line opacity while lines fade in or out with their ticks. */
+    pointOpacity: PropType<number[]>;
+    xAxisId: (StringConstructor | NumberConstructor)[];
+    yAxisId: (StringConstructor | NumberConstructor)[];
+    offset: PropType<ChartOffset>;
     xAxis: ObjectConstructor;
     yAxis: ObjectConstructor;
     vertical: (ObjectConstructor | BooleanConstructor)[];
-}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}>> & Readonly<{}>, {}, SlotsType<CartesianGridSlots>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default VerticalGridLines;

package/dist/cartesian/cartesian-grid/VerticalStripes.d.ts

@@ -1,20 +1,21 @@
+import { PropType } from 'vue';
 declare const VerticalStripes: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
-    verticalFill: ArrayConstructor;
+    verticalFill: PropType<string[]>;
     fillOpacity: NumberConstructor;
     x: NumberConstructor;
     y: NumberConstructor;
     width: NumberConstructor;
     height: NumberConstructor;
-    verticalPoints: ArrayConstructor;
+    verticalPoints: PropType<number[]>;
     vertical: (ObjectConstructor | BooleanConstructor)[];
-}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
-    verticalFill: ArrayConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    verticalFill: PropType<string[]>;
     fillOpacity: NumberConstructor;
     x: NumberConstructor;
     y: NumberConstructor;
     width: NumberConstructor;
     height: NumberConstructor;
-    verticalPoints: ArrayConstructor;
+    verticalPoints: PropType<number[]>;
     vertical: (ObjectConstructor | BooleanConstructor)[];
 }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default VerticalStripes;

package/dist/cartesian/cartesian-grid/const.d.ts

@@ -1,6 +1,2 @@
-import { CartesianGridProps } from './type';
-export declare const CartesianAxisDefaultProps: Partial<CartesianGridProps>;
-export type FilteredSvgElementType = 'svg' | 'polyline' | 'polygon';
-/** map of svg element types to unique svg attributes that belong to that element */
-export declare const FilteredElementKeyMap: Record<FilteredSvgElementType, string[]>;
-export declare const SVGElementPropKeys: string[];
+import { CartesianGridProps } from './type.js';
+export declare const CartesianGridDefaultProps: Partial<CartesianGridProps>;

package/dist/cartesian/cartesian-grid/type.d.ts

@@ -1,11 +1,9 @@
-import { CartesianAxisProps } from '../cartesian-axis/CartesianAxis';
-import { ViewBox } from '../type';
-import { ChartOffset, DataKey } from '../../types';
-import { AxisDomain, AxisDomainType, AxisId, AxisInterval, XAxisOrientation, YAxisOrientation } from '../../types/axis';
-import { RechartsScale, ScaleType } from '../../types/scale';
-import { AxisPropsNeededForTicksGenerator, GetTicksInput } from '../../types/tick';
-import { SVGAttributes, VNode } from 'vue';
-export type AxisPropsForCartesianGridTicksGeneration = AxisPropsNeededForTicksGenerator & Omit<GetTicksInput, 'ticks' | 'viewBox'>;
+import { AxisPropsNeededForTicksGenerator, CartesianTickItem, GetTicksInput } from '../../types/tick.js';
+import { ViewBox } from '../../types/viewBox.js';
+import { ChartOffset } from '../../types/index.js';
+import { AxisId, AxisInterval, XAxisOrientation, YAxisOrientation } from '../../types/axis.js';
+import { SVGAttributes, VNode, VNodeChild } from 'vue';
+type AxisPropsForCartesianGridTicksGeneration = AxisPropsNeededForTicksGenerator & Omit<GetTicksInput, 'ticks' | 'viewBox'>;
 export type HorizontalCoordinatesGenerator = (props: {
     yAxis: AxisPropsForCartesianGridTicksGeneration;
     width: number;
@@ -35,13 +33,13 @@ type LineItemProps = CartesianGridProps & {
     key: string;
     index: number;
 };
-export type GridLineTypeFunctionProps = Omit<LineItemProps, 'key'> & {
+type GridLineTypeFunctionProps = Omit<LineItemProps, 'key'> & {
     key: LineItemProps['key'] | undefined;
     offset: ChartOffset;
 };
 type GridLineType = SVGAttributes | VNode | ((props: GridLineTypeFunctionProps) => VNode) | boolean;
 export interface CartesianGridProps extends InternalCartesianGridProps {
-    ticks?: CartesianAxisProps['ticks'];
+    ticks?: ReadonlyArray<CartesianTickItem>;
     orientation?: XAxisOrientation | YAxisOrientation;
     viewBox?: ViewBox;
     ry?: SVGAttributes['ry'];
@@ -122,24 +120,17 @@ export interface CartesianGridProps extends InternalCartesianGridProps {
     tickMargin?: number;
     interval?: AxisInterval;
 }
-export declare const defaultProps: Partial<CartesianGridProps>;
-export type BaseCartesianAxis = {
-    id: AxisId;
-    scale: ScaleType | RechartsScale | undefined;
-    type: AxisDomainType;
-    /**
-     * The axis functionality is severely restricted without a dataKey
-     * - but there is still something left, and the prop is optional
-     * so this can also be undefined even in real charts.
-     * There are no defaults.
-     */
-    dataKey: DataKey<any> | undefined;
-    unit: string | undefined;
-    name: string | undefined;
-    allowDuplicatedCategory: boolean;
-    allowDataOverflow: boolean;
-    reversed: boolean;
-    includeHidden: boolean;
-    domain: AxisDomain | undefined;
-};
+export interface CartesianGridLineSlotProps extends Omit<SVGAttributes, 'offset'>, Record<string, unknown> {
+    x1?: number;
+    y1?: number;
+    x2?: number;
+    y2?: number;
+    index: number;
+    key?: string;
+    offset?: ChartOffset;
+}
+export interface CartesianGridSlots {
+    horizontal?: (props: CartesianGridLineSlotProps) => VNodeChild;
+    vertical?: (props: CartesianGridLineSlotProps) => VNodeChild;
+}
 export {};

package/dist/cartesian/cartesian-grid/utils.d.ts

@@ -1,5 +1,7 @@
+import { VNodeChild } from 'vue';
+import { CartesianGridLineSlotProps } from './type.js';
 /**
  * Render a grid line item.
  * Priority: slot > default <line> with optional SVG attr overrides from `option`.
  */
-export declare function renderLineItem(slot: ((...args: any[]) => any) | undefined, option: boolean | object, props: any): any;
+export declare function renderLineItem(slot: ((props: CartesianGridLineSlotProps) => VNodeChild) | undefined, option: boolean | object, props: CartesianGridLineSlotProps): VNodeChild;

package/dist/cartesian/cartesianPositionToCSSTranslate.d.ts

@@ -1,4 +1,4 @@
-import { TextAnchor, TextVerticalAnchor } from './getCartesianPosition';
+import { TextAnchor, TextVerticalAnchor } from './getCartesianPosition.js';
 /**
  * CalculatedCartesianPosition returns horizontalAnchor and verticalAnchor
  * which work directly with an SVG text element