vccs 0.6.0 → 1.0.0-beta.2

package/dist/polar/radial-bar/type.d.ts

@@ -1,17 +1,17 @@
+import { ChartDataKey } from '../../types/base.js';
 import { PropType } from 'vue';
-import { AnimationOptions } from 'motion-v';
-import { DataKey, VuePropsToType, WithSVGProps } from '../../types';
-import { LegendType } from '../../types/legend';
-import { TooltipType } from '../../types/tooltip';
-import { StackId } from '../../types/tick';
+import { ValueAnimationTransition } from 'motion-v';
+import { LegendType } from '../../types/legend.js';
+import { TooltipType } from '../../types/tooltip.js';
+import { StackId } from '../../types/tick.js';
 export declare const RadialBarVueProps: {
     dataKey: {
-        type: PropType<DataKey<any>>;
+        type: PropType<ChartDataKey>;
         required: true;
     };
     name: {
-        type: StringConstructor;
-        default: any;
+        type: PropType<string | number>;
+        default: undefined;
     };
     angleAxisId: {
         type: PropType<string | number>;
@@ -23,23 +23,23 @@ export declare const RadialBarVueProps: {
     };
     fill: {
         type: StringConstructor;
-        default: any;
+        default: undefined;
     };
     stroke: {
         type: StringConstructor;
-        default: any;
+        default: undefined;
     };
     fillOpacity: {
         type: NumberConstructor;
-        default: any;
+        default: undefined;
     };
     strokeWidth: {
         type: NumberConstructor;
-        default: any;
+        default: undefined;
     };
     strokeDasharray: {
         type: StringConstructor;
-        default: any;
+        default: undefined;
     };
     hide: {
         type: BooleanConstructor;
@@ -51,26 +51,23 @@ export declare const RadialBarVueProps: {
     };
     tooltipType: {
         type: PropType<TooltipType>;
-        default: any;
+        default: undefined;
     };
     background: {
-        type: PropType<boolean | Record<string, any>>;
+        type: PropType<boolean | Record<string, unknown>>;
         default: boolean;
     };
     label: {
-        type: PropType<boolean | Record<string, any>>;
+        type: PropType<boolean | Record<string, unknown>>;
         default: boolean;
     };
     isAnimationActive: {
         type: BooleanConstructor;
-        default: boolean;
+        default: undefined;
     };
     transition: {
-        type: PropType<AnimationOptions>;
-        default: () => {
-            duration: number;
-            ease: string;
-        };
+        type: PropType<ValueAnimationTransition<number>>;
+        default: undefined;
     };
     minPointSize: {
         type: NumberConstructor;
@@ -78,15 +75,15 @@ export declare const RadialBarVueProps: {
     };
     maxBarSize: {
         type: NumberConstructor;
-        default: any;
+        default: undefined;
     };
     barSize: {
         type: PropType<number | string>;
-        default: any;
+        default: undefined;
     };
     stackId: {
         type: PropType<StackId>;
-        default: any;
+        default: undefined;
     };
     cornerRadius: {
         type: PropType<number | string>;
@@ -100,5 +97,8 @@ export declare const RadialBarVueProps: {
         type: BooleanConstructor;
         default: boolean;
     };
+    class: {
+        type: PropType<import('../../types/index.js').VueClassValue>;
+        default: undefined;
+    };
 };
-export type RadialBarPropsWithSVG = WithSVGProps<VuePropsToType<typeof RadialBarVueProps>>;

package/dist/publicProps.d.ts

@@ -0,0 +1,96 @@
+import { Area } from './cartesian/area/Area.js';
+import { DeclaredProps } from './utils/attributes.js';
+import { AreaChart } from './chart/AreaChart.js';
+import { Bar } from './cartesian/bar/Bar.js';
+import { BarChart } from './chart/BarChart.js';
+import { Brush } from './cartesian/brush/Brush.js';
+import { CartesianAxis } from './cartesian/cartesian-axis/CartesianAxis.js';
+import { CartesianGrid } from './cartesian/cartesian-grid/CartesianGrid.js';
+import { ComposedChart } from './chart/ComposedChart.js';
+import { Curve } from './shape/Curve.js';
+import { Customized } from './components/Customized.js';
+import { Dot } from './shape/Dot.js';
+import { ErrorBar } from './cartesian/error-bar/ErrorBar.js';
+import { Funnel } from './cartesian/funnel/Funnel.js';
+import { FunnelChart } from './chart/FunnelChart.js';
+import { Label } from './components/label/Label.js';
+import { LabelList } from './components/label/LabelList.js';
+import { default as Legend } from './components/legend/Legend.js';
+import { Line } from './cartesian/line/Line.js';
+import { LineChart } from './chart/LineChart.js';
+import { Pie } from './polar/pie/Pie.js';
+import { PieChart } from './chart/PieChart.js';
+import { PolarAngleAxis } from './polar/radar/PolarAngleAxis.js';
+import { PolarGrid } from './polar/radar/PolarGrid.js';
+import { PolarRadiusAxis } from './polar/radar/PolarRadiusAxis.js';
+import { Radar } from './polar/radar/Radar.js';
+import { RadarChart } from './chart/RadarChart.js';
+import { RadialBar } from './polar/radial-bar/RadialBar.js';
+import { RadialBarChart } from './chart/RadialBarChart.js';
+import { Rectangle } from './shape/Rectangle.js';
+import { ReferenceArea } from './cartesian/reference-area/ReferenceArea.js';
+import { ReferenceDot } from './cartesian/reference-dot/ReferenceDot.js';
+import { ReferenceLine } from './cartesian/reference-line/ReferenceLine.js';
+import { Sankey } from './chart/Sankey.js';
+import { Scatter } from './cartesian/scatter/Scatter.js';
+import { ScatterChart } from './chart/ScatterChart.js';
+import { Sector } from './shape/Sector.js';
+import { SunburstChart } from './chart/SunburstChart.js';
+import { default as Text } from './components/Text.js';
+import { Tooltip } from './components/tooltip/Tooltip.js';
+import { Trapezoid } from './shape/Trapezoid.js';
+import { Treemap } from './chart/Treemap.js';
+import { XAxis } from './cartesian/axis/XAxis.js';
+import { YAxis } from './cartesian/axis/YAxis.js';
+import { ZAxis } from './cartesian/z-axis/ZAxis.js';
+export type AreaChartProps = DeclaredProps<typeof AreaChart>;
+export type AreaProps = DeclaredProps<typeof Area>;
+export type BarChartProps = DeclaredProps<typeof BarChart>;
+export type { BarListProps } from './chart/BarList.js';
+export type BarProps = DeclaredProps<typeof Bar>;
+export type BrushProps = DeclaredProps<typeof Brush>;
+export type { CalendarHeatmapProps } from './chart/CalendarHeatmap.js';
+export type CartesianAxisProps = DeclaredProps<typeof CartesianAxis>;
+export type CartesianGridProps = DeclaredProps<typeof CartesianGrid>;
+export type { CohortChartProps } from './chart/CohortChart.js';
+export type ComposedChartProps = DeclaredProps<typeof ComposedChart>;
+export type CurveProps = DeclaredProps<typeof Curve>;
+export type CustomizedProps = DeclaredProps<typeof Customized>;
+export type DotProps = DeclaredProps<typeof Dot>;
+export type ErrorBarProps = DeclaredProps<typeof ErrorBar>;
+export type FunnelChartProps = DeclaredProps<typeof FunnelChart>;
+export type FunnelProps = DeclaredProps<typeof Funnel>;
+export type { HeatmapProps } from './chart/Heatmap.js';
+export type { JourneySankeyProps } from './chart/JourneySankey.js';
+export type LabelListProps = DeclaredProps<typeof LabelList>;
+export type LabelProps = DeclaredProps<typeof Label>;
+export type LegendProps = DeclaredProps<typeof Legend>;
+export type LineChartProps = DeclaredProps<typeof LineChart>;
+export type LineProps = DeclaredProps<typeof Line>;
+export type PieChartProps = DeclaredProps<typeof PieChart>;
+export type PieProps = DeclaredProps<typeof Pie>;
+export type PolarAngleAxisProps = DeclaredProps<typeof PolarAngleAxis>;
+export type PolarGridProps = DeclaredProps<typeof PolarGrid>;
+export type PolarRadiusAxisProps = DeclaredProps<typeof PolarRadiusAxis>;
+export type RadarChartProps = DeclaredProps<typeof RadarChart>;
+export type RadarProps = DeclaredProps<typeof Radar>;
+export type RadialBarChartProps = DeclaredProps<typeof RadialBarChart>;
+export type RadialBarProps = DeclaredProps<typeof RadialBar>;
+export type RectangleProps = DeclaredProps<typeof Rectangle>;
+export type ReferenceAreaProps = DeclaredProps<typeof ReferenceArea>;
+export type ReferenceDotProps = DeclaredProps<typeof ReferenceDot>;
+export type ReferenceLineProps = DeclaredProps<typeof ReferenceLine>;
+export type SankeyProps = DeclaredProps<typeof Sankey>;
+export type ScatterChartProps = DeclaredProps<typeof ScatterChart>;
+export type ScatterProps = DeclaredProps<typeof Scatter>;
+export type SectorProps = DeclaredProps<typeof Sector>;
+export type { SparklineProps } from './chart/Sparkline.js';
+export type SunburstChartProps = DeclaredProps<typeof SunburstChart>;
+export type TextProps = DeclaredProps<typeof Text>;
+export type TooltipProps = DeclaredProps<typeof Tooltip>;
+export type { TrackerProps } from './chart/Tracker.js';
+export type TrapezoidProps = DeclaredProps<typeof Trapezoid>;
+export type TreemapProps = DeclaredProps<typeof Treemap>;
+export type XAxisProps = DeclaredProps<typeof XAxis>;
+export type YAxisProps = DeclaredProps<typeof YAxis>;
+export type ZAxisProps = DeclaredProps<typeof ZAxis>;

package/dist/resolver.d.ts

@@ -0,0 +1,9 @@
+export declare function VccsResolver(options?: {
+    prefix?: string;
+}): {
+    type: "component";
+    resolve(name: string): {
+        name: string;
+        from: string;
+    } | undefined;
+};

package/dist/shape/Cross.d.ts

@@ -1,4 +1,5 @@
 import { SVGAttributes } from 'vue';
+import { SvgTemplateAttributes } from '../utils/attributes.js';
 export interface CrossProps {
     x?: number;
     y?: number;
@@ -7,4 +8,4 @@ export interface CrossProps {
     top?: number;
     left?: number;
 }
-export declare function Cross(props: CrossProps & SVGAttributes): import("vue/jsx-runtime").JSX.Element;
+export declare function Cross(props: CrossProps & SVGAttributes & Omit<SvgTemplateAttributes, keyof CrossProps>): import("vue/jsx-runtime").JSX.Element | null;

package/dist/shape/Curve.d.ts

@@ -1,18 +1,8 @@
 import { PropType } from 'vue';
-import { CurveFactory } from 'victory-vendor/d3-shape';
-import { LayoutType, VuePropsToType, WithSVGProps } from '../types';
+import { CurveFactory } from 'd3-shape';
+import { LayoutType, WithSVGProps } from '../types/index.js';
+import { Point } from '../types/shape.js';
 export type CurveType = 'basis' | 'basisClosed' | 'basisOpen' | 'bumpX' | 'bumpY' | 'bump' | 'linear' | 'linearClosed' | 'natural' | 'monotoneX' | 'monotoneY' | 'monotone' | 'step' | 'stepBefore' | 'stepAfter' | CurveFactory;
-export interface Point {
-    readonly x: number;
-    readonly y: number;
-    readonly payload?: any;
-}
-type GetPathProps = Pick<CurveProps, 'type' | 'points' | 'baseLine' | 'layout' | 'connectNulls'>;
-/**
- * Calculate the path of curve. Returns null if points is an empty array.
- * @return path or null
- */
-export declare function getPath({ type, points, baseLine, layout, connectNulls, }: GetPathProps): string | null;
 export declare const CurveVueProps: {
     type: {
         type: PropType<CurveType | CurveFactory>;
@@ -33,11 +23,10 @@ export declare const CurveVueProps: {
         type: StringConstructor;
     };
     class: {
-        type: PropType<import('../types').VueClassValue>;
-        default: any;
+        type: PropType<import('../types/index.js').VueClassValue>;
+        default: undefined;
     };
 };
-export type CurvePropsWithOutSVG = VuePropsToType<typeof CurveVueProps>;
-export type CurveProps = WithSVGProps<typeof CurveVueProps>;
-export declare const Curve: import('vue').DefineComponent<CurveProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<CurveProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
-export {};
+/** Props as seen inside Curve; the public `CurveProps` is derived from the component in publicProps.ts. */
+export type CurveInput = WithSVGProps<typeof CurveVueProps>;
+export declare const Curve: import('vue').DefineComponent<CurveInput, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<CurveInput> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/shape/Dot.d.ts

@@ -1,18 +1,22 @@
-import { WithSVGProps } from '../types';
+import { WithSVGProps } from '../types/index.js';
 declare const DotVueProps: {
     cx: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: (StringConstructor | NumberConstructor)[];
     };
     cy: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: (StringConstructor | NumberConstructor)[];
     };
     r: {
-        type: (NumberConstructor | StringConstructor)[];
+        type: (StringConstructor | NumberConstructor)[];
     };
     clipDot: {
         type: BooleanConstructor;
     };
+    class: {
+        type: import('vue').PropType<import('../types/index.js').VueClassValue>;
+        default: undefined;
+    };
 };
-export type DotProps = WithSVGProps<typeof DotVueProps>;
-export declare const Dot: import('vue').DefineComponent<DotProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DotProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+type DotInput = WithSVGProps<typeof DotVueProps>;
+export declare const Dot: import('vue').DefineComponent<DotInput, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DotInput> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export {};

package/dist/shape/Polygon.d.ts

@@ -1,4 +1,5 @@
 import { SVGAttributes } from 'vue';
+import { SvgTemplateAttributes } from '../utils/attributes.js';
 export interface PolygonPoint {
     x: number;
     y: number;
@@ -6,4 +7,4 @@ export interface PolygonPoint {
 export interface PolygonProps {
     points?: PolygonPoint[];
 }
-export declare function Polygon(props: PolygonProps & SVGAttributes): import("vue/jsx-runtime").JSX.Element;
+export declare function Polygon(props: PolygonProps & Omit<SVGAttributes, keyof PolygonProps> & Omit<SvgTemplateAttributes, keyof PolygonProps>): import("vue/jsx-runtime").JSX.Element | null;

package/dist/shape/Rectangle.d.ts

@@ -1,13 +1,13 @@
 import { PropType } from 'vue';
-import { VuePropsToType, WithSVGProps } from '../types';
-import { RectRadius } from '../types/bar';
+import { WithSVGProps } from '../types/index.js';
+import { RectRadius } from '../types/bar.js';
 declare const RectangleVueProps: {
     x: {
-        type: PropType<number>;
+        type: PropType<number | null>;
         default: number;
     };
     y: {
-        type: PropType<number>;
+        type: PropType<number | null>;
         default: number;
     };
     width: {
@@ -20,10 +20,11 @@ declare const RectangleVueProps: {
     };
     radius: {
         type: PropType<number | RectRadius>;
-        default: any;
+        default: undefined;
     };
 };
-export type RectangleProps = VuePropsToType<typeof RectangleVueProps>;
-export type RectanglePropsWithSVG = WithSVGProps<typeof RectangleVueProps>;
-export declare const Rectangle: import('vue').DefineComponent<RectanglePropsWithSVG, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<RectanglePropsWithSVG> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+type RectangleInput = WithSVGProps<typeof RectangleVueProps>;
+/** The rectangle as a plain element; `attrs` must already be SVG attributes (see svgAttrs). */
+export declare function rectanglePath(attrs: Record<string, unknown>, x: number, y: number, width: number, height: number, radius?: number | RectRadius): import("vue/jsx-runtime").JSX.Element | null;
+export declare const Rectangle: import('vue').DefineComponent<RectangleInput, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<RectangleInput> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export {};

package/dist/shape/Sector.d.ts

@@ -1,5 +1,5 @@
 import { PropType } from 'vue';
-import { VuePropsToType, WithSVGProps } from '../types';
+import { VuePropsToType, WithSVGProps } from '../types/index.js';
 declare const SectorVueProps: {
     cx: {
         type: PropType<number>;
@@ -38,11 +38,12 @@ declare const SectorVueProps: {
         default: boolean;
     };
     class: {
-        type: PropType<import('../types').VueClassValue>;
-        default: any;
+        type: PropType<import('../types/index.js').VueClassValue>;
+        default: undefined;
     };
 };
-export type SectorProps = VuePropsToType<typeof SectorVueProps>;
-export type SectorPropsWithSVG = WithSVGProps<typeof SectorVueProps>;
-export declare const Sector: import('vue').DefineComponent<SectorPropsWithSVG, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SectorPropsWithSVG> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+/** Resolved sector geometry, also used for the RadialBar background. */
+export type SectorInput = VuePropsToType<typeof SectorVueProps>;
+type SectorAttrs = WithSVGProps<typeof SectorVueProps>;
+export declare const Sector: import('vue').DefineComponent<SectorAttrs, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SectorAttrs> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export {};

package/dist/shape/Symbols.d.ts

@@ -1,4 +1,4 @@
-import { VueClassValue } from '../types/common';
+import { VueClassValue } from '../types/common.js';
 export type SymbolType = 'circle' | 'cross' | 'diamond' | 'square' | 'star' | 'triangle' | 'wye';
 type SizeType = 'area' | 'diameter';
 export interface SymbolsProps {
@@ -10,7 +10,7 @@ export interface SymbolsProps {
     sizeType?: SizeType;
     fill?: string;
     stroke?: string;
-    [key: string]: any;
+    [key: string]: unknown;
 }
-export declare function Symbols(props: SymbolsProps): import("vue/jsx-runtime").JSX.Element;
+export declare function Symbols(props: SymbolsProps): import("vue/jsx-runtime").JSX.Element | null;
 export {};

package/dist/shape/Trapezoid.d.ts

@@ -1,4 +1,4 @@
-import { WithSVGProps } from '../types';
+import { WithSVGProps } from '../types/index.js';
 declare const TrapezoidVueProps: {
     x: {
         type: NumberConstructor;
@@ -21,10 +21,10 @@ declare const TrapezoidVueProps: {
         default: number;
     };
     class: {
-        type: import('vue').PropType<import('../types').VueClassValue>;
-        default: any;
+        type: import('vue').PropType<import('../types/index.js').VueClassValue>;
+        default: undefined;
     };
 };
-export type TrapezoidComponentProps = WithSVGProps<typeof TrapezoidVueProps>;
-export declare const Trapezoid: import('vue').DefineComponent<TrapezoidComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TrapezoidComponentProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+type TrapezoidInput = WithSVGProps<typeof TrapezoidVueProps>;
+export declare const Trapezoid: import('vue').DefineComponent<TrapezoidInput, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TrapezoidInput> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export {};

package/dist/typed.d.ts

@@ -0,0 +1,92 @@
+import { VNodeChild } from 'vue';
+import { RowDataKey } from './types/typed.js';
+import { HeatmapProps, HeatmapSlots } from './chart/Heatmap.js';
+import { CalendarHeatmapProps, CalendarHeatmapSlots } from './chart/CalendarHeatmap.js';
+import { CohortChartProps, CohortChartSlots } from './chart/CohortChart.js';
+import { TrackerProps, TrackerSlots } from './chart/Tracker.js';
+import { BarListProps, BarListSlots } from './chart/BarList.js';
+import { SparklineProps, SparklineSlots } from './chart/Sparkline.js';
+import { JourneySankeyProps, JourneySankeySlots } from './chart/JourneySankey.js';
+import { TooltipContentProps } from './components/tooltip/types.js';
+import { LegendContentProps } from './components/legend/type.js';
+import { LegendPayload } from './types/legend.js';
+import { TooltipPayload } from './types/tooltip.js';
+type RowArray<Value, Row> = Value extends readonly unknown[] ? RowItem<Value, Row> : Value;
+type ItemKeys<Item> = keyof {
+    [Key in keyof Item as string extends Key ? never : number extends Key ? never : Key]: Item[Key];
+};
+type RowObject<Item, Row> = {
+    [Key in keyof Item]: Key extends 'payload' ? Row : RowArray<Item[Key], Row>;
+} & ('payload' extends ItemKeys<Item> ? {
+    payload: Row;
+} : unknown);
+type RowItem<Item, Row> = Item extends readonly unknown[] ? {
+    [Index in keyof Item]: RowItem<Item[Index], Row>;
+} : Item extends object ? RowObject<Item, Row> : Item;
+type RowCallback<Value, Row> = Value extends (...args: infer Args) => infer Result ? (...args: {
+    [Index in keyof Args]: RowItem<Args[Index], Row>;
+}) => Result : Value;
+type RowProps<Props, Row> = {
+    [Key in keyof Props]: Key extends 'dataKey' | 'nameKey' ? RowDataKey<Row> : Key extends 'hidden' ? Array<Extract<RowDataKey<Row>, string>> : Key extends 'onUpdate:hidden' ? (hidden: Array<Extract<RowDataKey<Row>, string>>) => void : Key extends 'data' ? NonNullable<Props[Key]> extends readonly unknown[] ? Row[] : Props[Key] : RowCallback<Props[Key], Row>;
+};
+type RowSlots<Slots, Row> = {
+    [Key in keyof Slots]: RowCallback<Slots[Key], Row>;
+};
+type StandaloneComponent<Props, Slots> = {
+    new (): {
+        $props: Props;
+        $slots: Slots;
+    };
+};
+type StandaloneComponents<Row> = {
+    Heatmap: StandaloneComponent<HeatmapProps<Row>, HeatmapSlots<Row>>;
+    CalendarHeatmap: StandaloneComponent<CalendarHeatmapProps<Row>, CalendarHeatmapSlots<Row>>;
+    CohortChart: StandaloneComponent<CohortChartProps<Row>, CohortChartSlots<Row>>;
+    Tracker: StandaloneComponent<TrackerProps<Row>, TrackerSlots<Row>>;
+    BarList: StandaloneComponent<BarListProps<Row>, BarListSlots<Row>>;
+    Sparkline: StandaloneComponent<SparklineProps<Row>, SparklineSlots<Row>>;
+    JourneySankey: StandaloneComponent<JourneySankeyProps<Row>, JourneySankeySlots<Row>>;
+};
+export type TypedTooltipPayload<Row> = Omit<TooltipPayload[number], 'payload' | 'dataKey' | 'nameKey'> & {
+    payload: Row;
+    dataKey?: RowDataKey<Row>;
+    nameKey?: RowDataKey<Row>;
+};
+export type TypedTooltipContentProps<Row> = Pick<TooltipContentProps, 'active' | 'label' | 'coordinate' | 'accessibilityLayer'> & {
+    payload: TypedTooltipPayload<Row>[];
+};
+export type TypedLegendPayload<Row> = Omit<LegendPayload, 'dataKey'> & {
+    dataKey?: RowDataKey<Row>;
+};
+type ComponentConstructor = abstract new (...args: never[]) => {
+    $props: object;
+    $slots: object;
+};
+type TypedComponent<Component extends ComponentConstructor, Row, Slots = RowSlots<InstanceType<Component>['$slots'], Row>> = {
+    [Key in keyof Component]: Component[Key];
+} & {
+    new (): Omit<InstanceType<Component>, '$props' | '$slots'> & {
+        $props: RowProps<InstanceType<Component>['$props'], Row>;
+        $slots: Slots;
+    };
+};
+type SlotsOf<Component extends ComponentConstructor> = InstanceType<Component>['$slots'];
+type ContentPropsOf<Slots> = Slots extends {
+    content?: (props: infer Props) => unknown;
+} ? Props : never;
+type TypedSlots<Component extends ComponentConstructor, Row> = [
+    ContentPropsOf<SlotsOf<Component>>
+] extends [never] ? RowSlots<SlotsOf<Component>, Row> : [ContentPropsOf<SlotsOf<Component>>] extends [TooltipContentProps] ? Omit<SlotsOf<Component>, 'content'> & {
+    content?: (props: TypedTooltipContentProps<Row>) => VNodeChild;
+} : [ContentPropsOf<SlotsOf<Component>>] extends [LegendContentProps] ? {
+    content?: (props: Omit<LegendContentProps, 'payload'> & {
+        payload: TypedLegendPayload<Row>[];
+    }) => VNodeChild;
+} : RowSlots<SlotsOf<Component>, Row>;
+/** The components passed to `defineChartComponents`, re-typed for one row type. */
+export type TypedComponents<Row, Components> = {
+    [Key in keyof Components]: Key extends keyof StandaloneComponents<Row> ? StandaloneComponents<Row>[Key] : Components[Key] extends ComponentConstructor ? TypedComponent<Components[Key], Row, TypedSlots<Components[Key], Row>> : Components[Key];
+};
+/** Select runtime components while giving their keys and item payloads a row type. */
+export declare function defineChartComponents<Row>(): <Components extends object>(components: Components) => TypedComponents<Row, Components>;
+export {};

package/dist/types/area.d.ts

@@ -1,8 +1,7 @@
 export type BaseValue = number | 'dataMin' | 'dataMax';
-export interface DataPoint {
-    [key: string]: number | string | Date | undefined;
-}
-export interface AreaChartData extends DataPoint {
-    value: number;
-    date?: Date | string;
+export interface AreaPointItem {
+    x: number;
+    y: number;
+    value?: number | number[];
+    payload?: unknown;
 }

package/dist/types/axis.d.ts

@@ -1,9 +1,9 @@
-import { DataKey, VueClassValue } from './common';
-import { RechartsScale, ScaleType } from './scale';
-import { TickFormatter, TicksSettings } from './tick';
+import { ChartDataKey } from './base.js';
+import { AxisScale } from './scale.js';
+import { TickFormatter, TicksSettings } from './tick.js';
 export type AxisId = string | number;
-export type AxisDomainType = 'number' | 'category';
-export type AxisDomainItem = string | number | ((d: number) => string | number) | 'auto' | 'dataMin' | 'dataMax';
+type AxisDomainType = 'number' | 'category';
+type AxisDomainItem = string | number | ((d: number) => string | number) | 'auto' | 'dataMin' | 'dataMax';
 /**
  * The domain of axis.
  * This is the definition
@@ -26,7 +26,7 @@ export type AxisDomain = ReadonlyArray<string> | ReadonlyArray<number> | Readonl
  */
 export type BaseCartesianAxis = {
     id?: AxisId;
-    scale: ScaleType | RechartsScale | undefined;
+    scale: AxisScale | undefined;
     type: AxisDomainType;
     /**
      * The axis functionality is severely restricted without a dataKey
@@ -34,7 +34,7 @@ export type BaseCartesianAxis = {
      * so this can also be undefined even in real charts.
      * There are no defaults.
      */
-    dataKey: DataKey<any> | undefined;
+    dataKey: ChartDataKey | undefined;
     unit: string | undefined;
     name: string | undefined;
     allowDuplicatedCategory: boolean;
@@ -67,7 +67,7 @@ export type YAxisOrientation = 'left' | 'right';
  * Width of the Y axis in pixels.
  * `auto` will attempt to resize the axis based on its content.
  */
-export type YAxisWidth = number | 'auto';
+type YAxisWidth = number | 'auto';
 export type YAxisSettings = CartesianAxisSettings & {
     padding: YAxisPadding;
     width: YAxisWidth;
@@ -97,34 +97,6 @@ export type XAxisSettings = CartesianAxisSettings & {
     orientation: XAxisOrientation;
 };
 export type AxisType = 'xAxis' | 'yAxis' | 'zAxis' | 'angleAxis' | 'radiusAxis';
-export interface XAxisProps {
-    xAxisId?: string | number;
-    dataKey?: string | number | ((row: any) => any);
-    type?: 'number' | 'category';
-    domain?: any[];
-    scale?: string | Function;
-    orientation?: 'top' | 'bottom';
-    height?: number;
-    padding?: {
-        left?: number;
-        right?: number;
-    } | 'gap' | 'no-gap';
-    mirror?: boolean;
-    hide?: boolean;
-    tick?: boolean | Function | any;
-    tickCount?: number;
-    tickFormatter?: (val: any, idx: number) => string;
-    allowDataOverflow?: boolean;
-    allowDuplicatedCategory?: boolean;
-    allowDecimals?: boolean;
-    includeHidden?: boolean;
-    name?: string;
-    unit?: string;
-    angle?: number;
-    minTickGap?: number;
-    label?: string | number | any;
-    class?: VueClassValue;
-}
 /**
  * NumberDomain is an evaluated {@link AxisDomain}.
  * Unlike {@link AxisDomain}, it has no variety - it's a tuple of two number.
@@ -135,3 +107,4 @@ export interface XAxisProps {
  * There are also `category` axes that have different things than numbers in their domain.
  */
 export type NumberDomain = [min: number, max: number];
+export {};

package/dist/types/axisSettings.d.ts

@@ -0,0 +1,20 @@
+import { SVGAttributes } from 'vue';
+import { BaseCartesianAxis, CartesianAxisSettings as PublicCartesianAxisSettings, XAxisSettings as PublicXAxisSettings, YAxisSettings as PublicYAxisSettings, ZAxisSettings } from './axis.js';
+import { TicksSettings as PublicTicksSettings } from './tick.js';
+export type { AxisId, ZAxisSettings } from './axis.js';
+export type TicksSettings = Omit<PublicTicksSettings, 'tick' | 'tickCount'> & {
+    tickCount: number | undefined;
+    tick: SVGAttributes | boolean;
+};
+type CartesianAxisSettings = Omit<PublicCartesianAxisSettings, 'tick' | 'tickCount'> & TicksSettings;
+export type XAxisSettings = CartesianAxisSettings & Pick<PublicXAxisSettings, 'padding' | 'height' | 'orientation'>;
+export type YAxisSettings = CartesianAxisSettings & Pick<PublicYAxisSettings, 'padding' | 'width' | 'orientation'>;
+export type AngleAxisSettings = BaseCartesianAxis & TicksSettings;
+export type RadiusAxisSettings = BaseCartesianAxis & TicksSettings;
+export type AxisWithTicksSettings = XAxisSettings | YAxisSettings | AngleAxisSettings | RadiusAxisSettings;
+export type BaseAxisWithScale = Omit<BaseCartesianAxis, 'scale'> & {
+    scale: import('./scale.js').RechartsScale;
+};
+export type ZAxisWithScale = ZAxisSettings & {
+    scale: import('./scale.js').RechartsScale;
+};