vccs 0.6.0 → 1.0.0-beta.2

package/dist/events/itemEvents.d.ts

@@ -0,0 +1,100 @@
+import { BarRectangleItem } from '../types/bar.js';
+import { LinePointItem } from '../types/line.js';
+import { AreaPointItem } from '../core/area.js';
+import { ScatterPointItem } from '../types/common.js';
+import { PieSectorDataItem } from '../core/pie.js';
+import { RadarPoint } from '../types/radar.js';
+import { RadialBarDataItem } from '../types/radialBar.js';
+import { FunnelTrapezoidItem } from '../types/funnel.js';
+export declare const barEvents: {
+    emits: {
+        'update:activeIndex': (_index: number | null) => boolean;
+    } & {
+        click: (_entry: BarRectangleItem, _index: number, _event: MouseEvent) => boolean;
+        mouseenter: (_entry: BarRectangleItem, _index: number, _event: MouseEvent) => boolean;
+        mouseleave: (_entry: BarRectangleItem, _index: number, _event: MouseEvent) => boolean;
+        'animation-start': () => boolean;
+        'animation-end': () => boolean;
+    };
+    provide: (emit: ((event: "click", _entry: BarRectangleItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: BarRectangleItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: BarRectangleItem, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void) & ((event: "update:activeIndex", _index: number | null) => void)) => void;
+    use: () => NonNullable<((event: "click", _entry: BarRectangleItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: BarRectangleItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: BarRectangleItem, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void) & ((event: "update:activeIndex", _index: number | null) => void)>;
+};
+export declare const lineEvents: {
+    emits: Record<never, never> & {
+        click: (_entry: LinePointItem, _index: number, _event: MouseEvent) => boolean;
+        mouseenter: (_entry: LinePointItem, _index: number, _event: MouseEvent) => boolean;
+        mouseleave: (_entry: LinePointItem, _index: number, _event: MouseEvent) => boolean;
+        'animation-start': () => boolean;
+        'animation-end': () => boolean;
+    };
+    provide: (emit: ((event: "click", _entry: LinePointItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: LinePointItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: LinePointItem, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void)) => void;
+    use: () => NonNullable<((event: "click", _entry: LinePointItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: LinePointItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: LinePointItem, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void)>;
+};
+export declare const areaEvents: {
+    emits: Record<never, never> & {
+        click: (_entry: AreaPointItem, _index: number, _event: MouseEvent) => boolean;
+        mouseenter: (_entry: AreaPointItem, _index: number, _event: MouseEvent) => boolean;
+        mouseleave: (_entry: AreaPointItem, _index: number, _event: MouseEvent) => boolean;
+        'animation-start': () => boolean;
+        'animation-end': () => boolean;
+    };
+    provide: (emit: ((event: "click", _entry: AreaPointItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: AreaPointItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: AreaPointItem, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void)) => void;
+    use: () => NonNullable<((event: "click", _entry: AreaPointItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: AreaPointItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: AreaPointItem, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void)>;
+};
+export declare const scatterEvents: {
+    emits: Record<never, never> & {
+        click: (_entry: ScatterPointItem, _index: number, _event: MouseEvent) => boolean;
+        mouseenter: (_entry: ScatterPointItem, _index: number, _event: MouseEvent) => boolean;
+        mouseleave: (_entry: ScatterPointItem, _index: number, _event: MouseEvent) => boolean;
+        'animation-start': () => boolean;
+        'animation-end': () => boolean;
+    };
+    provide: (emit: ((event: "click", _entry: ScatterPointItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: ScatterPointItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: ScatterPointItem, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void)) => void;
+    use: () => NonNullable<((event: "click", _entry: ScatterPointItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: ScatterPointItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: ScatterPointItem, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void)>;
+};
+export declare const pieEvents: {
+    emits: {
+        'update:activeIndex': (_index: number | null) => boolean;
+    } & {
+        click: (_entry: PieSectorDataItem, _index: number, _event: MouseEvent) => boolean;
+        mouseenter: (_entry: PieSectorDataItem, _index: number, _event: MouseEvent) => boolean;
+        mouseleave: (_entry: PieSectorDataItem, _index: number, _event: MouseEvent) => boolean;
+        'animation-start': () => boolean;
+        'animation-end': () => boolean;
+    };
+    provide: (emit: ((event: "click", _entry: PieSectorDataItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: PieSectorDataItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: PieSectorDataItem, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void) & ((event: "update:activeIndex", _index: number | null) => void)) => void;
+    use: () => NonNullable<((event: "click", _entry: PieSectorDataItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: PieSectorDataItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: PieSectorDataItem, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void) & ((event: "update:activeIndex", _index: number | null) => void)>;
+};
+export declare const radarEvents: {
+    emits: Record<never, never> & {
+        click: (_entry: RadarPoint, _index: number, _event: MouseEvent) => boolean;
+        mouseenter: (_entry: RadarPoint, _index: number, _event: MouseEvent) => boolean;
+        mouseleave: (_entry: RadarPoint, _index: number, _event: MouseEvent) => boolean;
+        'animation-start': () => boolean;
+        'animation-end': () => boolean;
+    };
+    provide: (emit: ((event: "click", _entry: RadarPoint, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: RadarPoint, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: RadarPoint, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void)) => void;
+    use: () => NonNullable<((event: "click", _entry: RadarPoint, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: RadarPoint, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: RadarPoint, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void)>;
+};
+export declare const radialBarEvents: {
+    emits: Record<never, never> & {
+        click: (_entry: RadialBarDataItem, _index: number, _event: MouseEvent) => boolean;
+        mouseenter: (_entry: RadialBarDataItem, _index: number, _event: MouseEvent) => boolean;
+        mouseleave: (_entry: RadialBarDataItem, _index: number, _event: MouseEvent) => boolean;
+        'animation-start': () => boolean;
+        'animation-end': () => boolean;
+    };
+    provide: (emit: ((event: "click", _entry: RadialBarDataItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: RadialBarDataItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: RadialBarDataItem, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void)) => void;
+    use: () => NonNullable<((event: "click", _entry: RadialBarDataItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: RadialBarDataItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: RadialBarDataItem, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void)>;
+};
+export declare const funnelEvents: {
+    emits: Record<never, never> & {
+        click: (_entry: FunnelTrapezoidItem, _index: number, _event: MouseEvent) => boolean;
+        mouseenter: (_entry: FunnelTrapezoidItem, _index: number, _event: MouseEvent) => boolean;
+        mouseleave: (_entry: FunnelTrapezoidItem, _index: number, _event: MouseEvent) => boolean;
+        'animation-start': () => boolean;
+        'animation-end': () => boolean;
+    };
+    provide: (emit: ((event: "click", _entry: FunnelTrapezoidItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: FunnelTrapezoidItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: FunnelTrapezoidItem, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void)) => void;
+    use: () => NonNullable<((event: "click", _entry: FunnelTrapezoidItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseenter", _entry: FunnelTrapezoidItem, _index: number, _event: MouseEvent) => void) & ((event: "mouseleave", _entry: FunnelTrapezoidItem, _index: number, _event: MouseEvent) => void) & ((event: "animation-start") => void) & ((event: "animation-end") => void)>;
+};

package/dist/events/sync.d.ts

@@ -0,0 +1,6 @@
+import { TooltipSource } from '../model/tooltip.js';
+import { Chart } from '../model/chart.js';
+export declare function useTooltipChartSynchronisation(source: TooltipSource, enabled: () => boolean): void;
+/** Receive requests through the chart's configured synchronisation method. */
+export declare function useSynchronisedEventsFromOtherCharts(chart: Chart): void;
+export declare function useBrushChartSynchronisation(chart: Chart): void;

package/dist/events/useChartCallbacks.d.ts

@@ -0,0 +1,2 @@
+import { CategoricalChartFunc } from '../types/index.js';
+export declare function useChartCallbacks(): (handler: CategoricalChartFunc | undefined, event: MouseEvent | TouchEvent) => void;

package/dist/events/useChartInteractions.d.ts

@@ -0,0 +1,8 @@
+import { ChartPointer } from '../types/index.js';
+export declare function useChartInteractions(): {
+    click: (chartPointer: ChartPointer, target?: EventTarget | null) => void;
+    move: (chartPointer: ChartPointer, target?: EventTarget | null) => void;
+    keyDown: (event: KeyboardEvent) => void;
+    focus: () => void;
+    touchMove: (touchEvent: TouchEvent) => void;
+};

package/dist/events/useItemInteractions.d.ts

@@ -0,0 +1,7 @@
+export declare function useItemInteractions(): {
+    click: () => void;
+    move: () => void;
+    focus: () => void;
+    keyDown: (event: KeyboardEvent) => void;
+    touchMove: (event: TouchEvent) => void;
+};

package/dist/events/useItemKeyboard.d.ts

@@ -0,0 +1,24 @@
+interface ItemKeyboardOptions<Item> {
+    /** True while there is nothing to focus; every key is ignored then. */
+    empty: () => boolean;
+    /** The item keyboard focus starts on, or `undefined` when one is already active. */
+    start: () => Item | undefined;
+    /** The item a key moves to from the current one, or `undefined` when the key does nothing. */
+    neighbour: (key: string) => Item | undefined;
+    activate: (item: Item) => void;
+    /** Escape. */
+    clear: () => void;
+    /** Chart-specific keys such as Enter; returns true when it handled the event. */
+    keydown?: (event: KeyboardEvent) => boolean;
+}
+/**
+ * The keyboard channel every standalone item chart shares: focus that is visible starts on an
+ * item, keys move between items, Escape clears. `keyboard` tells whether the last selection
+ * came from the keyboard; pointer handlers reset it.
+ */
+export declare function useItemKeyboard<Item>(options: ItemKeyboardOptions<Item>): {
+    keyboard: import('vue').Ref<boolean, boolean>;
+    onFocus: (event: FocusEvent) => void;
+    onKeydown: (event: KeyboardEvent) => void;
+};
+export {};

package/dist/events/usePointEvents.d.ts

@@ -0,0 +1,23 @@
+import { EmitFn } from 'vue';
+type PointEmitter<Entry> = EmitFn<{
+    click: (entry: Entry, index: number, event: MouseEvent) => void;
+    mouseenter: (entry: Entry, index: number, event: MouseEvent) => void;
+    mouseleave: (entry: Entry, index: number, event: MouseEvent) => void;
+}>;
+export declare function usePointEvents<Entry extends {
+    x: number;
+    y: number;
+}>(emit: PointEmitter<Entry>): (entry: Entry, index: number) => {
+    onClick: (event: MouseEvent) => void;
+    onMouseenter: (event: MouseEvent) => void;
+    onMouseleave: (event: MouseEvent) => void;
+};
+export declare function useSeriesPointEvents<Entry extends {
+    x: number;
+    y: number;
+}>(emit: PointEmitter<Entry>, points: () => readonly Entry[]): {
+    onClick: (event: MouseEvent) => void;
+    onMouseenter: (event: MouseEvent) => void;
+    onMouseleave: (event: MouseEvent) => void;
+};
+export {};

package/dist/hooks/deferredView.d.ts

@@ -0,0 +1,12 @@
+import { Component } from 'vue';
+/**
+ * Returns the component that renders a chart item's geometry. Call during setup.
+ *
+ * Chart items register themselves during setup, but Vue mounts depth-first, so an item
+ * renders before later siblings (another series, an axis) have registered. A client-only
+ * mount corrects this before the first paint. The server renders only once, and hydration
+ * must reproduce the server HTML, so there the view is wrapped as an async component: Vue
+ * renders it after every sibling has run setup. Each instance needs its own wrapper,
+ * because an async component renders synchronously once it has resolved.
+ */
+export declare function useDeferredView<T extends Component>(view: T): T;

package/dist/hooks/publicHooks.d.ts

@@ -1,81 +1,79 @@
 import { ComputedRef } from 'vue';
-import { useChartHeight, useChartWidth, useMargin, useOffset } from '../context/chartLayoutContext';
-import { AxisId } from '../state/cartesianAxisSlice';
-import { Coordinate } from '../types/common';
-export type { InverseScaleFunction } from '../utils/createCategoricalInverse';
+import { AxisId } from '../types/axisSettings.js';
+import { Coordinate } from '../types/common.js';
+export type { InverseScaleFunction } from '../utils/createCategoricalInverse.js';
 export type ScaleFunction = (value: unknown) => number | undefined;
 export interface CartesianDataPoint {
     x: number | string;
     y: number | string;
 }
-export { useChartWidth, useChartHeight, useMargin, useOffset };
-export { useActiveTooltipDataPoints } from '../state/hooks';
+/** Returns the chart width in px. Must be used inside a chart component tree. */
+export declare function useChartWidth(): ComputedRef<number>;
+/** Returns the chart height in px. Must be used inside a chart component tree. */
+export declare function useChartHeight(): ComputedRef<number>;
+/** Returns the chart margin. Must be used inside a chart component tree. */
+export declare function useMargin(): ComputedRef<import('../types/common.js').Margin>;
 /**
  * Returns whether the tooltip is currently active (visible).
  *
- * Must be used inside a chart component tree (where the Redux store is provided).
+ * Must be used inside a chart component tree (where chart-local Vue state is provided).
  *
  * @returns A reactive boolean indicating tooltip active state
  */
-export declare function useIsTooltipActive(): Readonly<import('vue').ShallowRef<boolean>>;
+export declare function useIsTooltipActive(): ComputedRef<boolean>;
 /**
  * Returns the current coordinate of the active tooltip.
  *
- * Must be used inside a chart component tree (where the Redux store is provided).
+ * Must be used inside a chart component tree (where chart-local Vue state is provided).
  *
  * @returns A reactive Coordinate ({ x, y }) or undefined when no tooltip is active
  */
-export declare function useActiveTooltipCoordinate(): Readonly<import('vue').ShallowRef<Coordinate>>;
+export declare function useActiveTooltipCoordinate(): ComputedRef<Coordinate | undefined>;
 /**
  * Returns the label of the currently active tooltip (the value from the axis dataKey at the hovered index).
  *
- * Must be used inside a chart component tree (where the Redux store is provided).
+ * Must be used inside a chart component tree (where chart-local Vue state is provided).
  *
  * @returns A reactive string label or undefined when no tooltip is active
  */
-export declare function useActiveTooltipLabel(): Readonly<import('vue').ShallowRef<string | number>>;
+export declare function useActiveTooltipLabel(): ComputedRef<string | undefined>;
 /**
  * Returns the plot area rectangle { x, y, width, height }.
  * This is the area inside all axes, legend, and brush — where graphical items render.
  *
- * Must be used inside a chart component tree (where the Redux store is provided).
+ * Must be used inside a chart component tree (where chart-local Vue state is provided).
  *
  * @returns A reactive object with x, y, width, height or undefined if offset is not yet available
  */
-export declare function usePlotArea(): ComputedRef<{
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}>;
+export declare function usePlotArea(): ComputedRef<Required<import('../types/viewBox.js').CartesianViewBox>>;
 /**
  * Returns the computed domain of an X axis.
  *
  * @param axisId - The axis ID (defaults to 0)
  * @returns A reactive domain (categorical or numerical) or undefined
  */
-export declare function useXAxisDomain(axisId?: AxisId): Readonly<import('vue').ShallowRef<import('../types/axis').NumberDomain | import('../types').CategoricalDomain>>;
+export declare function useXAxisDomain(axisId?: AxisId): ComputedRef<import('../types/axis.js').NumberDomain | import('../types/index.js').CategoricalDomain | undefined>;
 /**
  * Returns the computed domain of a Y axis.
  *
  * @param axisId - The axis ID (defaults to 0)
  * @returns A reactive domain (categorical or numerical) or undefined
  */
-export declare function useYAxisDomain(axisId?: AxisId): Readonly<import('vue').ShallowRef<import('../types/axis').NumberDomain | import('../types').CategoricalDomain>>;
+export declare function useYAxisDomain(axisId?: AxisId): ComputedRef<import('../types/axis.js').NumberDomain | import('../types/index.js').CategoricalDomain | undefined>;
 /**
  * Returns the computed tick items of an X axis.
  *
  * @param axisId - The axis ID (defaults to 0)
  * @returns A reactive array of TickItem or undefined
  */
-export declare function useXAxisTicks(axisId?: AxisId): Readonly<import('vue').ShallowRef<readonly import('../types/common').TickItem[]>>;
+export declare function useXAxisTicks(axisId?: AxisId): ComputedRef<readonly import('../types/common.js').TickItem[] | undefined>;
 /**
  * Returns the computed tick items of a Y axis.
  *
  * @param axisId - The axis ID (defaults to 0)
  * @returns A reactive array of TickItem or undefined
  */
-export declare function useYAxisTicks(axisId?: AxisId): Readonly<import('vue').ShallowRef<readonly import('../types/common').TickItem[]>>;
+export declare function useYAxisTicks(axisId?: AxisId): ComputedRef<readonly import('../types/common.js').TickItem[] | undefined>;
 /**
  * Returns the scale function for an X axis, mapping data values to pixel coordinates.
  *
@@ -96,42 +94,42 @@ export declare function useYAxisScale(axisId?: AxisId): ComputedRef<ScaleFunctio
  * @param axisId - The axis ID (defaults to 0)
  * @returns A reactive InverseScaleFunction or undefined
  */
-export declare function useXAxisInverseScale(axisId?: AxisId): Readonly<import('vue').ShallowRef<import('../utils/createCategoricalInverse').InverseScaleFunction>>;
+export declare function useXAxisInverseScale(axisId?: AxisId): ComputedRef<import('../utils/createCategoricalInverse.js').InverseScaleFunction | undefined>;
 /**
  * Returns the inverse scale function for a Y axis, mapping pixel coordinates back to data values.
  *
  * @param axisId - The axis ID (defaults to 0)
  * @returns A reactive InverseScaleFunction or undefined
  */
-export declare function useYAxisInverseScale(axisId?: AxisId): Readonly<import('vue').ShallowRef<import('../utils/createCategoricalInverse').InverseScaleFunction>>;
+export declare function useYAxisInverseScale(axisId?: AxisId): ComputedRef<import('../utils/createCategoricalInverse.js').InverseScaleFunction | undefined>;
 /**
  * Returns the inverse scale function for an X axis that snaps to the nearest data point.
  *
  * @param axisId - The axis ID (defaults to 0)
  * @returns A reactive InverseScaleFunction or undefined
  */
-export declare function useXAxisInverseDataSnapScale(axisId?: AxisId): Readonly<import('vue').ShallowRef<import('../utils/createCategoricalInverse').InverseScaleFunction>>;
+export declare function useXAxisInverseDataSnapScale(axisId?: AxisId): ComputedRef<import('../utils/createCategoricalInverse.js').InverseScaleFunction | undefined>;
 /**
  * Returns the inverse scale function for a Y axis that snaps to the nearest data point.
  *
  * @param axisId - The axis ID (defaults to 0)
  * @returns A reactive InverseScaleFunction or undefined
  */
-export declare function useYAxisInverseDataSnapScale(axisId?: AxisId): Readonly<import('vue').ShallowRef<import('../utils/createCategoricalInverse').InverseScaleFunction>>;
+export declare function useYAxisInverseDataSnapScale(axisId?: AxisId): ComputedRef<import('../utils/createCategoricalInverse.js').InverseScaleFunction | undefined>;
 /**
  * Returns the inverse scale function for an X axis that snaps to the nearest tick.
  *
  * @param axisId - The axis ID (defaults to 0)
  * @returns A reactive InverseScaleFunction or undefined
  */
-export declare function useXAxisInverseTickSnapScale(axisId?: AxisId): Readonly<import('vue').ShallowRef<import('../utils/createCategoricalInverse').InverseScaleFunction>>;
+export declare function useXAxisInverseTickSnapScale(axisId?: AxisId): ComputedRef<((pixel: number) => unknown) | undefined>;
 /**
  * Returns the inverse scale function for a Y axis that snaps to the nearest tick.
  *
  * @param axisId - The axis ID (defaults to 0)
  * @returns A reactive InverseScaleFunction or undefined
  */
-export declare function useYAxisInverseTickSnapScale(axisId?: AxisId): Readonly<import('vue').ShallowRef<import('../utils/createCategoricalInverse').InverseScaleFunction>>;
+export declare function useYAxisInverseTickSnapScale(axisId?: AxisId): ComputedRef<((pixel: number) => unknown) | undefined>;
 /**
  * Convenience hook that maps a data point to pixel coordinates using both X and Y axis scales.
  *

package/dist/hooks/useActiveTooltipDataPoints.d.ts

@@ -0,0 +1,2 @@
+/** Currently displayed data points, deduplicated across series. Requires a tooltip source. */
+export declare function useActiveTooltipDataPoints(): import('vue').ComputedRef<{}[]>;

package/dist/hooks/useChartId.d.ts

@@ -0,0 +1,2 @@
+/** SSR-stable DOM id for `url(#...)` references. Call during setup. */
+export declare function useChartId(prefix: string): string;

package/dist/hooks/useLayerTeleport.d.ts

@@ -0,0 +1,5 @@
+import { Ref, VNode } from 'vue';
+/** Keep the first render inline so hydration reproduces the server's SVG tree. */
+export declare function useLayerTeleport(): (content: VNode, target: Ref<string | Element | null | undefined> | null | undefined) => VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>;

package/dist/hooks/useResponsiveSize.d.ts

@@ -1,22 +1,37 @@
-import { ComputedRef } from 'vue';
-import { CategoricalChartPropsWithOutSvg } from '../chart/generateCategoricalChart';
-type ResponsiveSizeProps = Pick<CategoricalChartPropsWithOutSvg, 'responsive' | 'width' | 'height'>;
-interface UseResponsiveSizeResult {
-    /** Final width: measured from the wrapper when `responsive`, otherwise from props. */
-    effectiveWidth: ComputedRef<number>;
-    /** Final height: measured from the wrapper when `responsive`, otherwise from props. */
-    effectiveHeight: ComputedRef<number>;
-    /** Whether the effective size passes validateWidthHeight. Render policy is the caller's decision. */
-    hasValidSize: ComputedRef<boolean>;
-    /** Feeds the wrapper's ResizeObserver callback. Rounds and ignores no-change updates. */
-    handleResize: (width: number, height: number) => void;
+import { CSSProperties, PropType } from 'vue';
+import { RoundedSize } from './useRoundedSize.js';
+export declare const chartSizeProps: {
+    width: {
+        type: NumberConstructor;
+    };
+    height: {
+        type: NumberConstructor;
+    };
+    aspect: {
+        type: NumberConstructor;
+    };
+    initialDimension: {
+        type: PropType<RoundedSize>;
+    };
+};
+interface ChartSizeProps {
+    width?: number;
+    height?: number;
+    aspect?: number;
+    initialDimension?: RoundedSize;
 }
 /**
- * Owns the chart's size resolution: in responsive mode the size is measured
- * from the wrapper div (via `handleResize`), otherwise it comes from props.
- *
- * Render gating (`return null` when the size is invalid) stays with the
- * caller — the rules differ between the compact and normal branches.
+ * Resolves the chart size per dimension: a finite nonnegative `width` or `height` prop is fixed, a missing or invalid
+ * one follows the measured box. The server and the first client render share the same initial
+ * geometry, so hydration matches; measurement happens after mount.
  */
-export declare function useResponsiveSize(props: ResponsiveSizeProps): UseResponsiveSizeResult;
+export declare function useResponsiveSize(props: ChartSizeProps): {
+    effectiveWidth: import('vue').ComputedRef<number>;
+    effectiveHeight: import('vue').ComputedRef<number>;
+    hasValidSize: import('vue').ComputedRef<boolean>;
+    handleResize: (width: number, height: number) => void;
+    isResponsive: import('vue').ComputedRef<boolean>;
+    measured: import('vue').Ref<boolean, boolean>;
+    boxStyle: import('vue').ComputedRef<CSSProperties>;
+};
 export {};

package/dist/hooks/useRoundedSize.d.ts

@@ -6,9 +6,6 @@ export interface RoundedSize {
  * Shared size-state core: a size ref plus a setter that rounds to
  * integers and ignores no-change updates.
  *
- * Adapters: `useResponsiveSize` (chart sizing) and `ResponsiveContainer`.
- * ResponsiveContainer is planned for removal (see ADR-0001); when it goes,
- * this module stays behind as the chart's size-state implementation.
  */
 export declare function useRoundedSize(initial?: RoundedSize): {
     size: import('vue').Ref<{

package/dist/hooks/useSeriesProps.d.ts

@@ -0,0 +1,7 @@
+import { ChartAnimation } from '../model/animation.js';
+export declare function getSeriesId(props: object): symbol | undefined;
+/** Share effective settings between series rendering and registration. */
+export declare function useSeriesProps<T extends ChartAnimation & {
+    hide?: boolean;
+    dataKey?: unknown;
+}>(props: T, colors?: readonly ('fill' | 'stroke')[]): T;

package/dist/hooks/useSetupGraphicalItem.d.ts

@@ -1,7 +1,38 @@
-import { AreaProps } from '../cartesian/area/type';
-import { CartesianGraphicalItemType, ErrorBarsSettings } from '../state/graphicalItemsSlice';
-import { ShallowRef } from 'vue';
-export declare function useSetupGraphicalItem(props: AreaProps | any, type: CartesianGraphicalItemType, options?: {
+import { Coordinate } from '../types/index.js';
+import { TooltipPayloadConfiguration } from '../types/tooltip.js';
+import { Ref, ShallowRef } from 'vue';
+import { MinPointSize } from '../types/shape.js';
+import { AreaInput } from '../cartesian/area/type.js';
+import { LegendPayload } from '../types/legend.js';
+import { CartesianGraphicalItemSettings, CartesianGraphicalItemType, ErrorBarsSettings, PolarGraphicalItemSettings } from '../types/graphical.js';
+import { ChartDataKey } from '../types/base.js';
+import { AxisId } from '../types/axisSettings.js';
+type GraphicalItemProps = Partial<Pick<AreaInput, 'dataKey' | 'stackId' | 'hide' | 'xAxisId' | 'yAxisId' | 'stroke' | 'fill' | 'name' | 'legendType' | 'tooltipType' | 'unit'>> & {
+    data?: readonly unknown[];
+    strokeDasharray?: string | number;
+    strokeWidth?: string | number;
+    zAxisId?: AxisId;
+    barSize?: number | string;
+    minPointSize?: MinPointSize;
+};
+export declare function useSetupGraphicalItem(props: GraphicalItemProps, type: CartesianGraphicalItemType, options?: {
     skipTooltip?: boolean;
     errorBars?: ShallowRef<ReadonlyArray<ErrorBarsSettings>>;
+}): {
+    data: import('vue').ComputedRef<unknown[] | undefined>;
+    settings: import('vue').ComputedRef<CartesianGraphicalItemSettings>;
+};
+/**
+ * Registers a polar series (Pie, Radar, RadialBar, Funnel) and its legend items. The hook owns
+ * the shared fields: the series type, its dataKey, and `hide`, which also marks the legend
+ * items inactive. `settings` adds the series' own fields (axis ids, bar sizing, data).
+ */
+export declare function useSetupPolarItem(props: {
+    dataKey: ChartDataKey;
+    hide: boolean;
+}, type: PolarGraphicalItemSettings['type'], options: {
+    settings?: () => Partial<Omit<PolarGraphicalItemSettings, 'type' | 'dataKey' | 'hide'>>;
+    legend: () => readonly Omit<LegendPayload, 'dataKey' | 'inactive'>[];
 }): void;
+export declare function useSetupTooltipEntry(props: GraphicalItemProps, type: CartesianGraphicalItemType, data: Readonly<Ref<readonly unknown[] | undefined>>, positions?: () => readonly Coordinate[] | undefined, model?: TooltipPayloadConfiguration['model']): import('vue').ComputedRef<TooltipPayloadConfiguration>;
+export {};

package/dist/hooks/useTrackedData.d.ts

@@ -0,0 +1,3 @@
+import { ComputedRef } from 'vue';
+/** Track each data owner once, including values consumed only by raw calculations. */
+export declare function useTrackedData<T>(source: () => readonly T[] | undefined): ComputedRef<T[] | undefined>;