@primeui/vue-chart 0.0.1-alpha.1

package/dist/composables/index.d.ts

@@ -0,0 +1,35 @@
+export { useAnimationProps } from './useAnimationProps';
+export { useAxisComponentBase } from './useAxisComponentBase';
+export { useDatasetAnimationRegistration } from './useDatasetAnimationContext';
+export { useAxisRegistration } from './useAxisRegistration';
+export { useAxisTransition } from './useAxisTransition';
+export { useCandlestickRenderer } from './useCandlestickRenderer';
+export { useCartesianAnimation } from './useCartesianAnimation';
+export { useCartesianLayout } from './useCartesianLayout';
+export { useChartContext } from './useChartContext';
+export { useChartRefreshHook } from './useChartRefreshHook';
+export { useChartSync } from './useChartSync';
+export { useChartSyncCoordinator } from './useChartSyncCoordinator';
+export { useCustomizationRegistration } from './useCustomizationRegistration';
+export { useDatasetRegistration } from './useDatasetRegistration';
+export { useDrilldownState } from './useDrilldownState';
+export { provideFamilyRenderers, registerFamilyRenderer, type ChartFamily, type FamilyRendererRegistry } from './useFamilyRenderers';
+export { provideNavigatorRenderer, registerNavigatorRenderer } from './useNavigatorRenderer';
+export { provideZoomController, registerZoomController, type ZoomControllerCtor } from './useZoomController';
+export { provideKeyboardController, registerKeyboardController, type KeyboardControllerCtor } from './useKeyboardController';
+export { provideChartLayers, registerChartLayer, useChartLayers, type ChartLayerEntry, type ChartLayerRegistry, type FrameKind } from './useChartLayers';
+export { provideRadialFrame, useRadialFrameRegistration, type RadialFrame, type RadialLayerHandle } from './useRadialFrame';
+export { provideCartesianFrame, useCartesianFrame, useCartesianFrameRegistration, type CartesianFrame, type CartesianFrameShared, type CartesianLayerHandle } from './useCartesianFrame';
+export { useHeatmapRenderer } from './useHeatmapRenderer';
+export { useItemCollector } from './useItemCollector';
+export { useKeyboardNavigation } from './useKeyboardNavigation';
+export { useLineRenderer } from './useLineRenderer';
+export { usePieRenderer } from './usePieRenderer';
+export { usePolarRenderer } from './usePolarRenderer';
+export { useRadarRenderer } from './useRadarRenderer';
+export { useResponsiveConfig } from './useResponsiveConfig';
+export { useResponsiveDimensions } from './useResponsiveDimensions';
+export { useScatterRenderer } from './useScatterRenderer';
+export { useTreemapRenderer } from './useTreemapRenderer';
+export { usePropertyAnimations } from './usePropertyAnimations';
+export { useZoomPan } from './useZoomPan';

package/dist/composables/useAnimationProps.d.ts

@@ -0,0 +1,21 @@
+import type { MaybeRefOrGetter } from 'vue';
+import type { ChartAnimationProps } from '@primeui/chart-types';
+import type { ChartMethodsContextValue } from '../types';
+/**
+ * Parses the chart-level `animation` / `animations` / `transitions` props and
+ * registers them as the singleton `'animation'` customization feature.
+ *
+ * Called from Chart.vue's setup right after `provideChartContext`. Vue 3's
+ * `inject()` walks the parent chain and cannot see the current component's
+ * own `provide()`, so the caller passes its locally resolved `methods` in
+ * explicitly — mirroring the pure-composable style used in vue-scheduler.
+ *
+ * Per-dataset `animations` props register themselves directly under
+ * `animation:${datasetId}` keys via `useDatasetAnimationRegistration` (see
+ * each ChartBar/ChartLine/etc. SFC). The CartesianRenderer reads all
+ * `animation:*` keys and merges them with this chart-level entry.
+ *
+ * `transitions` is parsed but not yet wired to triggers in Phase 1a — it lives
+ * on the feature payload so Phase 3 can hook into it.
+ */
+export declare function useAnimationProps(props: MaybeRefOrGetter<ChartAnimationProps>, methods: ChartMethodsContextValue): void;

package/dist/composables/useAxisComponentBase.d.ts

@@ -0,0 +1,11 @@
+import { type Ref } from 'vue';
+import type { SharedAxisProps, UseAxisComponentBaseResult } from '../types';
+/**
+ * Shared logic for ChartXAxis and ChartYAxis.
+ *
+ * Handles:
+ * - Axis props construction
+ * - useAxisRegistration call
+ * - AxisGroup children collection
+ */
+export declare function useAxisComponentBase(axis: 'x' | 'y', axisId: Ref<string>, props: SharedAxisProps, hasChildren?: boolean): UseAxisComponentBaseResult;

package/dist/composables/useAxisRegistration.d.ts

@@ -0,0 +1,7 @@
+import type { Ref } from 'vue';
+import type { XAxisProps as CoreXAxisProps, YAxisProps as CoreYAxisProps } from '../types';
+/**
+ * Composable for axis registration lifecycle.
+ * Delegates all lifecycle logic to AxisRegistrationController in chart-core.
+ */
+export declare function useAxisRegistration(axis: 'x' | 'y', id: Ref<string>, props: Ref<CoreXAxisProps | CoreYAxisProps>): void;

package/dist/composables/useAxisTransition.d.ts

@@ -0,0 +1,6 @@
+import { AxisTransitionState } from '@primeui/chart-core';
+/**
+ * Vue composable wrapping the framework-agnostic AxisTransitionState.
+ * Instance persists for the component lifetime (plain variable in setup).
+ */
+export declare function useAxisTransition(): AxisTransitionState;

package/dist/composables/useBarLayer.d.ts

@@ -0,0 +1,9 @@
+import { useCartesianFrame } from './index';
+import { useChartMethods } from '../context';
+import type { UseBarRendererOptions, UseBarRendererResult } from '../types';
+export interface UseBarLayerResult {
+    bar: UseBarRendererResult;
+    methods: ReturnType<typeof useChartMethods>;
+    frame: NonNullable<ReturnType<typeof useCartesianFrame>>;
+}
+export declare function useBarLayer(useBarRenderer: (options: UseBarRendererOptions) => UseBarRendererResult): UseBarLayerResult;

package/dist/composables/useBarRenderer.canvas.d.ts

@@ -0,0 +1,2 @@
+import type { UseBarRendererOptions, UseBarRendererResult } from '../types';
+export declare function useBarRenderer(options: UseBarRendererOptions): UseBarRendererResult;

package/dist/composables/useBarRenderer.svg.d.ts

@@ -0,0 +1,2 @@
+import type { UseBarRendererOptions, UseBarRendererResult } from '../types';
+export declare function useBarRenderer(options: UseBarRendererOptions): UseBarRendererResult;

package/dist/composables/useBarRendererBase.d.ts

@@ -0,0 +1,3 @@
+import type { BarRendererController } from '@primeui/chart-core';
+import type { UseBarRendererOptions, UseBarRendererResult } from '../types';
+export declare function useBarRendererBase(controller: BarRendererController, options: UseBarRendererOptions): UseBarRendererResult;

package/dist/composables/useCandlestickRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { UseCandlestickRendererOptions, UseCandlestickRendererResult } from '../types';
+export declare function useCandlestickRenderer(options: UseCandlestickRendererOptions): UseCandlestickRendererResult;

package/dist/composables/useCartesianAnimation.d.ts

@@ -0,0 +1,2 @@
+import type { UseCartesianAnimationOptions } from '../types';
+export declare function useCartesianAnimation(options: UseCartesianAnimationOptions): void;

package/dist/composables/useCartesianFrame.d.ts

@@ -0,0 +1,72 @@
+import { type ComputedRef, type Ref, type VNode } from 'vue';
+import type { AnimatedPropertyStoreLike, CanvasCompositorLike } from '@primeui/chart-types';
+import type { normalizeDataLabelConfig } from '@primeui/chart-core';
+import type { BandScale, BoxArea, CartesianHitTestResult, CartesianLayoutData, ColorScaleInfo, CrosshairSeriesHit, CustomMarkerEntry, HoverConfig, LinearScale, ZoomState } from '../types';
+type LabelConfig = ReturnType<typeof normalizeDataLabelConfig> | null;
+export interface CartesianLayerHandle {
+    type: string;
+    hitTest(x: number, y: number): CartesianHitTestResult | null;
+    findNearest?(x: number, y: number): CartesianHitTestResult | null;
+    findAllNearest?(x: number, y: number): {
+        primary: CartesianHitTestResult;
+        allSeries: CrosshairSeriesHit[];
+    } | null;
+    getPointPosition(datasetId: string, index: number): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        shape: 'rect' | 'circle';
+    } | null;
+    /** Render-prop data labels (bar/line) — frame renders these on top, after chrome. */
+    dataLabelVNodes?: Ref<VNode[]>;
+    /** Custom marker overlays (line/scatter) — frame composites these in the marker group. */
+    markerOverlays?: Ref<CustomMarkerEntry[]>;
+    /** Property-animation appliers (bar/line) — frame's onAnimFrame iterates these. */
+    applyPropertyAnimations?(store: AnimatedPropertyStoreLike): void;
+    /** Restore-on-release — frame's onPropertyComplete iterates these when a non-looping property animation completes. */
+    renderFrameCycle?(): void;
+    /** Line + scatter track the chrome-animated scales every frame. `valueXScales` carries
+     *  the animated X value axis (scatter's numeric X). */
+    syncWithAnimatedScale?(categoryScale: BandScale, valueScales?: Map<string, LinearScale>, valueXScales?: Map<string, LinearScale>): void;
+    /** Scatter boost — frame skips chrome repaint on hover when all-scatter in boost. */
+    boostActive?: Ref<boolean>;
+    /** Heatmap self-contained color scale + band scales. */
+    getColorScaleInfo?(): ColorScaleInfo | null;
+    scaleResult?: Ref<{
+        xScale: BandScale;
+        yScale: BandScale;
+        xCategories: string[];
+        yCategories: string[];
+    } | null>;
+}
+/** The frame-computed bundle layers read. */
+export interface CartesianFrameShared {
+    canvasEl: Ref<HTMLCanvasElement | null>;
+    width: ComputedRef<number>;
+    height: ComputedRef<number>;
+    /** Plot-area clip-path element id. Series layers render `<g>` at the template root (so they
+     *  mount in both renderers), each clipping itself — equivalent to the old wrapping clip group. */
+    plotClipId: string;
+    cartesianArea: ComputedRef<BoxArea>;
+    layoutData: ComputedRef<CartesianLayoutData | null>;
+    labelConfig: ComputedRef<LabelConfig>;
+    hoverConfig: ComputedRef<HoverConfig | undefined>;
+    zoomState: ComputedRef<ZoomState | null>;
+    adaptiveDataLabelFontSize: ComputedRef<number | undefined>;
+    adaptiveDataLabelRotation: ComputedRef<number | undefined>;
+    compositor: CanvasCompositorLike;
+    animStore: Ref<AnimatedPropertyStoreLike | null>;
+}
+export interface CartesianFrame extends CartesianFrameShared {
+    handles: Map<string, CartesianLayerHandle>;
+    register(handle: CartesianLayerHandle): void;
+    unregister(type: string): void;
+}
+/** Called by CartesianRenderer with its computed shared bundle. */
+export declare function provideCartesianFrame(shared: CartesianFrameShared): CartesianFrame;
+/** Called by a layer to read the shared bundle. */
+export declare function useCartesianFrame(): CartesianFrame | null;
+/** Called by a layer to register its handle; auto-unregisters on unmount. */
+export declare function useCartesianFrameRegistration(handle: CartesianLayerHandle): void;
+export {};

package/dist/composables/useCartesianLayout.d.ts

@@ -0,0 +1,3 @@
+import { type ComputedRef } from 'vue';
+import type { CartesianLayoutData, UseCartesianLayoutOptions } from '../types';
+export declare function useCartesianLayout(options: UseCartesianLayoutOptions): ComputedRef<CartesianLayoutData | null>;

package/dist/composables/useChartContext.d.ts

@@ -0,0 +1,40 @@
+import type { ChartTheme, RendererDelegate, SyncedHighlightResult } from '@primeui/chart-types';
+import { type ComputedRef, type Ref, type ShallowRef } from 'vue';
+import type { ChartCoreInstanceContextValue } from '../context/keys';
+import type { ChartSyncInfo } from '../types/chart.types';
+import type { LegendItem, TooltipState } from '../types';
+export interface UseChartContextOptions {
+    coreCtx: ChartCoreInstanceContextValue;
+    width: Ref<number> | ComputedRef<number>;
+    height: Ref<number> | ComputedRef<number>;
+    dir: Ref<'ltr' | 'rtl'> | ComputedRef<'ltr' | 'rtl'>;
+    theme: ComputedRef<Required<ChartTheme>>;
+    rendererDelegate: ComputedRef<RendererDelegate | null>;
+    drilldownEnabled: ComputedRef<boolean>;
+    onClickCb: ComputedRef<((hit: {
+        datasetId: string;
+        index: number;
+        label: string;
+        value: number;
+        color: string;
+    }) => void) | undefined>;
+    onLegendClickCb: ComputedRef<((item: {
+        datasetId: string;
+        index?: number;
+        label: string;
+        type: 'dataset' | 'item';
+    }) => void) | undefined>;
+    syncInfo: ChartSyncInfo | null;
+    containerRef: Ref<HTMLDivElement | null>;
+}
+export interface UseChartContextResult {
+    tooltip: ShallowRef<TooltipState | null>;
+    onMouseMove: (x: number, y: number) => void;
+    onMouseLeave: () => void;
+    onClick: (x: number, y: number) => void;
+    onLegendClick: (item: LegendItem) => void;
+    onLegendHover: (item: LegendItem | null) => void;
+    /** Routes a synced-highlight result through core so state flows via emits. */
+    onSyncedResult: (result: SyncedHighlightResult) => void;
+}
+export declare function useChartContext(options: UseChartContextOptions): UseChartContextResult;

package/dist/composables/useChartLayers.d.ts

@@ -0,0 +1,31 @@
+import { type Component } from 'vue';
+import type { DatasetRenderer } from '@primeui/chart-types';
+import type { ChartFamily } from './useFamilyRenderers';
+/** `'grid'` = attaches to a coordinate grid frame (axes/scales). `null` = frameless (center/radius slices, rect packing). */
+export type FrameKind = 'grid' | null;
+export interface ChartLayerEntry {
+    family: ChartFamily;
+    frameKind: FrameKind;
+    /** Single shared layer (mode-agnostic types). */
+    layer?: Component;
+    /** Per-renderer-mode layer. Used by renderer-mode-split types (e.g. bar) so the
+     *  family renderer mounts only the layer matching the active renderer. The two
+     *  variants statically import different painter-construction modules, so the
+     *  unused-mode layer (and its painter) can drop from a single-mode consumer's
+     *  bundle. Exactly one of `layer` / `layerByMode` is set. */
+    layerByMode?: {
+        svg: Component;
+        canvas: Component;
+    };
+    /** Renderer's axis-hint provider, contributed at <ChartX> setup so the frame reserves axis
+     *  space without statically importing the renderer (keeps the renderer out of the frame bundle). */
+    axisHints?: Pick<DatasetRenderer<unknown, unknown>, 'getAxisHints'>;
+}
+export type ChartLayerRegistry = Map<string, ChartLayerEntry>;
+/** Called by the <Chart> root. Provides an empty reactive registry that
+ *  chart-type components populate during their own setup. */
+export declare function provideChartLayers(): ChartLayerRegistry;
+/** Called in a chart-type component's setup(). First registration wins. */
+export declare function registerChartLayer(type: string, entry: ChartLayerEntry): void;
+/** Read the registered layers for a family (e.g. RadialRenderer reads `'radial'`). */
+export declare function useChartLayers(): ChartLayerRegistry | null;

package/dist/composables/useChartRefreshHook.d.ts

@@ -0,0 +1 @@
+export declare function useChartRefreshHook(callback: () => void): void;

package/dist/composables/useChartSync.d.ts

@@ -0,0 +1,2 @@
+import type { UseChartSyncOptions, UseChartSyncResult } from '../types';
+export declare function useChartSync(options: UseChartSyncOptions): UseChartSyncResult;

package/dist/composables/useChartSyncCoordinator.d.ts

@@ -0,0 +1,23 @@
+import type { ChartTheme, DatasetRegistration, RendererDelegate, SyncedHighlightResult, ZoomState } from '@primeui/chart-types';
+import { type ComputedRef, type Ref } from 'vue';
+import type { ChartSyncInfo } from '../types';
+export interface UseChartSyncCoordinatorOptions {
+    syncInfo: ChartSyncInfo | null;
+    datasets: ComputedRef<Map<string, DatasetRegistration>>;
+    datasetVisibility: ComputedRef<Map<string, boolean>>;
+    theme: ComputedRef<Required<ChartTheme>>;
+    zoomState: Ref<ZoomState>;
+    hasCrosshair: ComputedRef<boolean>;
+    isSharedMode: ComputedRef<boolean>;
+    isCartesian: ComputedRef<boolean>;
+    isRect: ComputedRef<boolean>;
+    width: Ref<number>;
+    height: Ref<number>;
+    getZoomState: () => ZoomState;
+    rendererDelegate: ComputedRef<RendererDelegate | null>;
+    updateZoom: (state: ZoomState) => void;
+    setDatasetVisibility: (seriesId: string, visible: boolean) => void;
+    toggleItemVisibility: (seriesId: string, itemLabel: number) => void;
+    onSyncedResult: (result: SyncedHighlightResult) => void;
+}
+export declare function useChartSyncCoordinator({ syncInfo, datasets, datasetVisibility, theme, zoomState, hasCrosshair, isSharedMode, isCartesian, isRect, width, height, getZoomState, rendererDelegate, updateZoom, setDatasetVisibility, toggleItemVisibility, onSyncedResult }: UseChartSyncCoordinatorOptions): void;

package/dist/composables/useControllerLifecycle.d.ts

@@ -0,0 +1,18 @@
+import type { AnimatedPropertyStoreLike } from '@primeui/chart-types';
+/** The minimal controller surface every renderer controller shares. */
+interface LifecycleController {
+    destroy(): void;
+    applyPropertyAnimations(store: AnimatedPropertyStoreLike): void;
+    renderFrameCycle(): void;
+}
+export interface ControllerLifecycle {
+    applyPropertyAnimations: (store: AnimatedPropertyStoreLike) => void;
+    renderFrameCycle: () => void;
+}
+/**
+ * Wire a renderer controller's universal lifecycle: destroy on unmount, plus the
+ * two stable pass-through delegates. Returns the delegates to spread into the
+ * composable's return object.
+ */
+export declare function useControllerLifecycle(controller: LifecycleController): ControllerLifecycle;
+export {};

package/dist/composables/useCustomizationRegistration.d.ts

@@ -0,0 +1,18 @@
+import type { Ref } from 'vue';
+import type { ChartMethodsContextValue, FeaturePropsMap, FeatureType } from '../types';
+/**
+ * Composable for customization/feature registration lifecycle.
+ * Handles register on mount, update on prop changes, unregister on unmount.
+ *
+ * Generic K-keyed: `type` and `props` are linked via `FeaturePropsMap`, so
+ * `useCustomizationRegistration('hover', refOf<HoverProps>)` typechecks without
+ * a cast at call sites.
+ *
+ * `methodsOverride` is for the chart root (Chart.vue), which both provides the
+ * chart context AND wants to register the chart-level `animation` feature in
+ * the same setup. Vue 3's `inject()` only walks the parent chain — it cannot
+ * see the current component's own `provide()` — so the root passes its locally
+ * resolved methods directly. Child customization components (legend, navigator,
+ * dataset registrations) leave this undefined and inject normally.
+ */
+export declare function useCustomizationRegistration<K extends FeatureType>(type: K, props: Ref<FeaturePropsMap[K]>, methodsOverride?: ChartMethodsContextValue): void;

package/dist/composables/useDatasetAnimationContext.d.ts

@@ -0,0 +1,14 @@
+import type { MaybeRefOrGetter } from 'vue';
+import type { NamedAnimationSpec } from '@primeui/chart-types';
+/**
+ * Wires a dataset's `animations` prop into the chart's feature map under a
+ * per-dataset keyed entry (`animation:${datasetId}`), matching the same
+ * keyed-registration pattern used by `ChartReferenceLine` / `ChartReferenceBand`
+ * / `ChartAxisGroup`. The CartesianRenderer reads all `animation:*` keys and
+ * merges their `propertyAnimations` arrays alongside the chart-level `animation`
+ * entry.
+ *
+ * No parent state, no provide/inject — each dataset writes directly to the
+ * chart core's single source of truth.
+ */
+export declare function useDatasetAnimationRegistration(datasetId: MaybeRefOrGetter<string | undefined>, animations: MaybeRefOrGetter<Record<string, NamedAnimationSpec> | undefined>): void;

package/dist/composables/useDatasetRegistration.d.ts

@@ -0,0 +1,6 @@
+import type { UseDatasetRegistrationOptions } from '../types';
+/**
+ * Composable for dataset registration lifecycle.
+ * Delegates all lifecycle logic to DatasetRegistrationController in chart-core.
+ */
+export declare function useDatasetRegistration<T extends Record<string, unknown>>({ id, type, props, typeResolver }: UseDatasetRegistrationOptions<T>): void;

package/dist/composables/useDrilldownState.d.ts

@@ -0,0 +1,3 @@
+import { type ComputedRef } from 'vue';
+import type { DatasetRegistration, DrilldownStateResult } from '../types';
+export declare function useDrilldownState(datasets: ComputedRef<Map<string, DatasetRegistration>>): DrilldownStateResult;

package/dist/composables/useFamilyRenderers.d.ts

@@ -0,0 +1,10 @@
+import { type Component } from 'vue';
+export type ChartFamily = 'cartesian' | 'radial' | 'rect';
+export type FamilyRendererRegistry = Record<ChartFamily, Component | undefined>;
+/** Called by the <Chart> root. Provides an empty reactive registry that
+ *  chart-type components populate during their own setup. */
+export declare function provideFamilyRenderers(): FamilyRendererRegistry;
+/** Called in a chart-type component's setup(). The component statically imports
+ *  its family renderer (so the renderer tree-shakes with the component) and
+ *  registers it. First registration wins; subsequent ones are idempotent. */
+export declare function registerFamilyRenderer(family: ChartFamily, component: Component): void;

package/dist/composables/useFamilyRenderers.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/composables/useHeatmapRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { UseHeatmapRendererOptions, UseHeatmapRendererResult } from '../types';
+export declare function useHeatmapRenderer(options: UseHeatmapRendererOptions): UseHeatmapRendererResult;

package/dist/composables/useItemCollector.d.ts

@@ -0,0 +1,2 @@
+import type { UseItemCollectorResult } from '../types';
+export declare function useItemCollector<T extends object>(): UseItemCollectorResult<T>;

package/dist/composables/useKeyboardController.d.ts

@@ -0,0 +1,8 @@
+import { type ShallowRef } from 'vue';
+import type { KeyboardNavigationController } from '@primeui/chart-core';
+export type KeyboardControllerCtor = new () => KeyboardNavigationController;
+/** Called by the <Chart> root. Provides an empty slot that <Chart.Accessibility> fills. */
+export declare function provideKeyboardController(): ShallowRef<KeyboardControllerCtor | null>;
+/** Called in <Chart.Accessibility>'s setup(). Statically imports
+ *  KeyboardNavigationController (so it tree-shakes with the feature) and registers it. */
+export declare function registerKeyboardController(ctor: KeyboardControllerCtor): void;

package/dist/composables/useKeyboardNavigation.d.ts

@@ -0,0 +1,2 @@
+import type { UseKeyboardNavigationOptions, UseKeyboardNavigationResult } from '../types';
+export declare function useKeyboardNavigation(options: UseKeyboardNavigationOptions): UseKeyboardNavigationResult;

package/dist/composables/useLineRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { UseLineRendererOptions, UseLineRendererResult } from '../types';
+export declare function useLineRenderer(options: UseLineRendererOptions): UseLineRendererResult;

package/dist/composables/useNavigatorRenderer.d.ts

@@ -0,0 +1,7 @@
+import { type Component, type ShallowRef } from 'vue';
+/** Called by the <Chart> root. Provides an empty slot that <Chart.Navigator>
+ *  populates during its own setup when the feature is present in the tree. */
+export declare function provideNavigatorRenderer(): ShallowRef<Component | null>;
+/** Called in <Chart.Navigator>'s setup(). The component statically imports
+ *  NavigatorRenderer (so it tree-shakes with the feature) and registers it. */
+export declare function registerNavigatorRenderer(component: Component): void;

package/dist/composables/usePieRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { UsePieRendererOptions, UsePieRendererResult } from '../types';
+export declare function usePieRenderer(options: UsePieRendererOptions): UsePieRendererResult;

package/dist/composables/usePolarRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { UsePolarRendererOptions, UsePolarRendererResult } from '../types';
+export declare function usePolarRenderer(options: UsePolarRendererOptions): UsePolarRendererResult;

package/dist/composables/usePropertyAnimations.d.ts

@@ -0,0 +1,4 @@
+import type { MaybeRefOrGetter } from 'vue';
+import type { AnimatedPropertyStoreLike, PropertyAnimationConfig } from '@primeui/chart-types';
+import type { AnimationRegistry } from '@primeui/chart-core';
+export declare function usePropertyAnimations(configs: MaybeRefOrGetter<PropertyAnimationConfig[] | undefined>, registry: AnimationRegistry | null, store: AnimatedPropertyStoreLike | null, onPropertyComplete?: (storeKey: string) => void): void;

package/dist/composables/useRadarRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { UseRadarRendererOptions, UseRadarRendererResult } from '../types';
+export declare function useRadarRenderer(options: UseRadarRendererOptions): UseRadarRendererResult;

package/dist/composables/useRadialFrame.d.ts

@@ -0,0 +1,39 @@
+import { type Ref } from 'vue';
+import type { AnimatedPropertyStoreLike } from '@primeui/chart-types';
+import type { CrosshairSeriesHit, PolarRenderData, RadarRenderData, RadialHitTestResult } from '../types';
+export interface RadialLayerHandle {
+    type: string;
+    hitTest(x: number, y: number): RadialHitTestResult | null;
+    getPointPosition(datasetId: string, index: number): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        shape: 'circle';
+    } | null;
+    getCenter?(): {
+        x: number;
+        y: number;
+    } | null;
+    findAllNearest?(x: number, y: number): {
+        primary: RadialHitTestResult;
+        allSeries: CrosshairSeriesHit[];
+    } | null;
+    /** Grid layers (radar/polar) expose their per-frame layout so the frame can build the shared radial grid. */
+    layout?: Ref<RadarRenderData | PolarRenderData | null>;
+    /** Grid layers expose their canvas painter so the frame's redraw pipeline can composite grid + series. */
+    renderCanvasContent?: (ctx: CanvasRenderingContext2D, canvas: HTMLCanvasElement) => void;
+    /** Property-animation appliers — frame's onAnimFrame iterates these (scaffolded for Tasks 3-9). */
+    applyPropertyAnimations?(store: AnimatedPropertyStoreLike): void;
+    /** Restore-on-release — frame's onPropertyComplete iterates these when a non-looping property animation completes. */
+    renderFrameCycle?(): void;
+}
+export interface RadialFrame {
+    handles: Map<string, RadialLayerHandle>;
+    register(handle: RadialLayerHandle): void;
+    unregister(type: string): void;
+}
+/** Called by RadialRenderer. */
+export declare function provideRadialFrame(): RadialFrame;
+/** Called in a layer's setup(); auto-unregisters on unmount. */
+export declare function useRadialFrameRegistration(handle: RadialLayerHandle): void;

package/dist/composables/useResponsiveConfig.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from 'vue';
+import type { ResponsiveFeatureProps } from '../types';
+export declare function useResponsiveConfig(width: Ref<number>, height: Ref<number>, responsiveFeature: Ref<ResponsiveFeatureProps | undefined>, globalFont?: {
+    size?: number;
+}): {
+    defaults: import("vue").ComputedRef<import("packages/components/chart/chart-types/src").AdaptiveDefaults>;
+    ruleOverrides: import("vue").ComputedRef<Record<string, Record<string, unknown>>>;
+};

package/dist/composables/useResponsiveDimensions.d.ts

@@ -0,0 +1,2 @@
+import type { UseResponsiveDimensionsOptions, UseResponsiveDimensionsResult } from '../types';
+export declare function useResponsiveDimensions(options: UseResponsiveDimensionsOptions): UseResponsiveDimensionsResult;

package/dist/composables/useScatterRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { UseScatterRendererOptions, UseScatterRendererResult } from '../types';
+export declare function useScatterRenderer(options: UseScatterRendererOptions): UseScatterRendererResult;

package/dist/composables/useTreemapRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { UseTreemapRendererOptions, UseTreemapRendererResult } from '../types';
+export declare function useTreemapRenderer(options: UseTreemapRendererOptions): UseTreemapRendererResult;

package/dist/composables/useZoomController.d.ts

@@ -0,0 +1,9 @@
+import { type ShallowRef } from 'vue';
+import type { ZoomPanDeps } from '@primeui/chart-types';
+import type { ZoomPanController } from '@primeui/chart-core';
+export type ZoomControllerCtor = new (deps: ZoomPanDeps) => ZoomPanController;
+/** Called by the <Chart> root. Provides an empty slot that <Chart.Zoom> fills. */
+export declare function provideZoomController(): ShallowRef<ZoomControllerCtor | null>;
+/** Called in <Chart.Zoom>'s setup(). Statically imports ZoomPanController (so it
+ *  tree-shakes with the feature) and registers its constructor. */
+export declare function registerZoomController(ctor: ZoomControllerCtor): void;

package/dist/composables/useZoomPan.d.ts

@@ -0,0 +1,2 @@
+import type { UseZoomPanOptions, UseZoomPanResult } from '../types';
+export declare function useZoomPan(options: UseZoomPanOptions): UseZoomPanResult;

package/dist/context/ChartContext.d.ts

@@ -0,0 +1,21 @@
+import type { ComputedRef } from 'vue';
+import type { ChartHoverContextValue, ChartMethodsContextValue, ChartProviderOptions, ChartStateContextValue, RendererHint } from '../types';
+/** Access stable chart methods (registration, actions). */
+export declare function useChartMethods(): ChartMethodsContextValue;
+/** Access reactive chart state (datasets, features, visibility). */
+export declare function useChartState(): ComputedRef<ChartStateContextValue>;
+/** Access hover state only. */
+export declare function useChartHover(): ComputedRef<ChartHoverContextValue>;
+/** Set the renderer hint synchronously in setup(). Called by chart components. */
+export declare function useRendererHint(hint: RendererHint): void;
+export declare function provideChartContext(options: ChartProviderOptions): {
+    coreChart: import("@primeui/chart-core").ChartCoreInstance;
+    emitHandlerRef: {
+        current: ((event: string, ...args: unknown[]) => void) | null;
+    };
+    methods: ChartMethodsContextValue;
+    state: ComputedRef<ChartStateContextValue>;
+    hover: ComputedRef<ChartHoverContextValue>;
+    rendererHint: import("vue").Ref<RendererHint | null, RendererHint | null>;
+    redraw: () => void;
+};

package/dist/context/index.d.ts

@@ -0,0 +1,4 @@
+export { provideChartContext, useChartHover, useChartMethods, useChartState, useRendererHint } from './ChartContext';
+export { CHART_GROUP_TEXT_KEY, CHART_HOVER_KEY, CHART_METHODS_KEY, CHART_STATE_KEY, ITEM_COLLECTOR_KEY, RENDERER_HINT_KEY } from './keys';
+export type { ChartGroupTextContextValue } from './keys';
+export { CHART_SYNC_INFO_KEY, SYNC_BUS_KEY } from './syncKeys';

package/dist/context/keys.d.ts

@@ -0,0 +1,52 @@
+import type { ChartCoreInstance } from '@primeui/chart-core';
+import type { ComputedRef, InjectionKey, Ref, ShallowRef } from 'vue';
+import type { ChartHoverContextValue, ChartMethodsContextValue, ChartStateContextValue, ItemCollectorContextValue, RendererHint, TooltipState } from '../types';
+export interface ChartCoreInstanceContextValue {
+    coreChart: ChartCoreInstance;
+    /** Write your emit handler here; provideChartContext's stable wrappers call it for all event emits. */
+    emitHandlerRef: {
+        current: ((event: string, ...args: unknown[]) => void) | null;
+    };
+    setHover: (datasetId: string | null, index: number | null, axisIdx?: number | null, axisX?: number | null) => void;
+}
+export interface ChartGroupTextContextValue {
+    setTitle: (text: string | undefined) => void;
+    setCaption: (text: string | undefined) => void;
+}
+/**
+ * Provides stable methods (registration, actions, static info).
+ * Rarely changes — only on dimension updates.
+ */
+export declare const CHART_METHODS_KEY: InjectionKey<ChartMethodsContextValue>;
+/**
+ * Provides reactive chart state (datasets, features, visibility).
+ * Provided as ComputedRef — consumers access .value for reactivity.
+ */
+export declare const CHART_STATE_KEY: InjectionKey<ComputedRef<ChartStateContextValue>>;
+/**
+ * Provides hover state — separated for performance.
+ * Provided as ComputedRef — consumers access .value for reactivity.
+ */
+export declare const CHART_HOVER_KEY: InjectionKey<ComputedRef<ChartHoverContextValue>>;
+export declare const ITEM_COLLECTOR_KEY: InjectionKey<ItemCollectorContextValue<any>>;
+/**
+ * Renderer hint — synchronously set by chart components (ChartBar, ChartScatter, etc.)
+ * so ChartRenderer knows which sub-renderer to mount on the very first render,
+ * before datasets register via onMounted.
+ */
+export declare const RENDERER_HINT_KEY: InjectionKey<Ref<RendererHint | null>>;
+/** Provided by ChartGroup — lets ChartTitle/ChartCaption register group-level text. */
+export declare const CHART_GROUP_TEXT_KEY: InjectionKey<ChartGroupTextContextValue>;
+/** Tooltip state — provided by ChartRenderer, injected by TooltipRenderer.
+ *  Decouples tooltip position updates from ChartRenderer's render cycle. */
+export declare const TOOLTIP_CONTEXT_KEY: InjectionKey<ShallowRef<TooltipState | null>>;
+/** Core chart instance + emit handler slot — injected by useChartContext. */
+export declare const CHART_CORE_INSTANCE_KEY: InjectionKey<ChartCoreInstanceContextValue>;
+/**
+ * Refresh nonce — incremented by `chart.redraw()` to force a one-shot bypass
+ * of the framework wrapper's prop-equality gate. Lets users imperatively
+ * push fresh prop values (including new function refs) into chart state when
+ * only function references changed and the smart shallowEqual would otherwise
+ * short-circuit the update.
+ */
+export declare const CHART_REFRESH_NONCE_KEY: InjectionKey<Ref<number>>;

package/dist/context/syncKeys.d.ts

@@ -0,0 +1,5 @@
+import type { InjectionKey } from 'vue';
+import type { ChartSyncInfo, SyncBus } from '../types';
+/** Injection key for the shared SyncBus (provided by ChartGroup) */
+export declare const SYNC_BUS_KEY: InjectionKey<SyncBus>;
+export declare const CHART_SYNC_INFO_KEY: InjectionKey<ChartSyncInfo>;