@primeui/vue-chart 0.0.1-alpha.1

package/dist/types/keyboard.types.d.ts

@@ -0,0 +1,24 @@
+import type { DatasetRegistration, FocusPosition, KeyboardNavigationConfig, KeyboardNavState, RendererDelegate } from '@primeui/chart-types';
+import type { ComputedRef, Ref } from 'vue';
+export interface UseKeyboardNavigationOptions {
+    enabled: ComputedRef<boolean>;
+    config: ComputedRef<KeyboardNavigationConfig | undefined>;
+    datasets: ComputedRef<Map<string, DatasetRegistration>>;
+    datasetVisibility: ComputedRef<Map<string, boolean>>;
+    setHover: (datasetId: string | null, index: number | null) => void;
+    rendererDelegate: ComputedRef<RendererDelegate | null>;
+    /** Drives the focused point through the mouse-move pipeline (tooltip + crosshair + sync). */
+    emitFocusMove?: (x: number, y: number) => void;
+    /** Clears the focus-driven tooltip/hover/crosshair (mouse-leave equivalent). */
+    emitFocusLeave?: () => void;
+}
+export interface UseKeyboardNavigationResult {
+    state: Ref<KeyboardNavState>;
+    focusPosition: ComputedRef<FocusPosition | null>;
+    announcement: Ref<string>;
+    onKeyDown: (e: KeyboardEvent) => void;
+    onMouseMove: () => void;
+    onFocus: () => void;
+    onBlur: () => void;
+    notifyPointerDown: () => void;
+}

package/dist/types/layout.types.d.ts

@@ -0,0 +1,35 @@
+import type { AnyFeatureProps, AxisConfig, BoxArea, ChartTheme, DatasetRegistration, FeatureType, HoverConfig, RendererType, ZoomState } from '@primeui/chart-types';
+import type { ComputedRef, Ref } from 'vue';
+export interface UseCartesianLayoutOptions {
+    cartesianArea: ComputedRef<BoxArea | null>;
+    datasets: ComputedRef<Map<string, DatasetRegistration>>;
+    axes: ComputedRef<{
+        x: Map<string, AxisConfig>;
+        y: Map<string, AxisConfig>;
+    }>;
+    features: ComputedRef<Map<FeatureType, {
+        type: FeatureType;
+        props: AnyFeatureProps;
+    }>>;
+    datasetVisibility: ComputedRef<Map<string, boolean>>;
+    hover: Ref<{
+        datasetId: string | null;
+        index: number | null;
+    }>;
+    hoverConfig: ComputedRef<HoverConfig | undefined>;
+    chartId: string;
+    renderer: RendererType;
+    width: ComputedRef<number>;
+    height: ComputedRef<number>;
+    zoomState?: ComputedRef<ZoomState | null>;
+    /** Reactive dir ref — `.value` is read inside the layout computed so direction changes trigger re-layout. */
+    dir?: Ref<'ltr' | 'rtl'>;
+    globalFont?: {
+        family?: string;
+        size?: number;
+    };
+    /** Reactive locale ref — `.value` is read inside the layout computed so locale changes trigger re-layout. */
+    locale?: Ref<string | undefined>;
+    /** Reactive theme — read via `.value` inside the composable. */
+    theme: ComputedRef<Required<ChartTheme>>;
+}

package/dist/types/legend.types.d.ts

@@ -0,0 +1,13 @@
+import type { ColorLegendProps as CoreColorLegendProps, ColorLegendRenderContext, LegendProps as CoreLegendProps, LegendItemRenderContext } from '@primeui/chart-types';
+import type { CSSProperties, VNode } from 'vue';
+export interface ChartLegendProps extends CoreLegendProps {
+    render?: (context: LegendItemRenderContext) => VNode | VNode[] | string | null;
+    /** Custom CSS class (shared mode only) */
+    class?: string;
+    /** Custom inline styles (shared mode only) */
+    style?: CSSProperties;
+}
+export interface ColorLegendProps extends Omit<CoreColorLegendProps, 'render'> {
+    /** Custom render function for the color legend. When provided, replaces the default gradient bar entirely. */
+    render?: (context: ColorLegendRenderContext) => VNode | null;
+}

package/dist/types/line.types.d.ts

@@ -0,0 +1,64 @@
+import type { AnimatedPropertyStoreLike, CanvasCompositorLike, AnyFeatureProps, BandScale, BoxArea, CartesianHitTestResult, CartesianLayoutData, ChartTheme, ColorValue, CrosshairSeriesHit, DatasetRegistration, FeatureType, FrameDataLabelConfig, HoverConfig, LinearScale, LineHitTestResult, LineProps, LineRenderData, LineRenderProps, MarkerOverlayEntry } from '@primeui/chart-types';
+import type { ComputedRef, Ref, ShallowRef, VNode } from 'vue';
+export type { LineAnimationConfig } from '@primeui/chart-types';
+export type ChartLineProps<T = unknown> = LineProps<T, VNode | null>;
+export interface UseLineRendererOptions {
+    chartArea: ComputedRef<BoxArea>;
+    renderer: 'svg' | 'canvas';
+    canvasEl: Ref<HTMLCanvasElement | null> | ShallowRef<HTMLCanvasElement | null>;
+    datasets: ComputedRef<Map<string, DatasetRegistration>>;
+    datasetVisibility: ComputedRef<Map<string, boolean>>;
+    hover: ComputedRef<{
+        datasetId: string | null;
+        index: number | null;
+    }>;
+    hoverConfig: ComputedRef<HoverConfig | undefined>;
+    chartId: string;
+    width: ComputedRef<number>;
+    height: ComputedRef<number>;
+    categoryScale: ComputedRef<BandScale | undefined>;
+    valueScales: ComputedRef<Map<string, LinearScale> | undefined>;
+    firstValueAxisId: ComputedRef<string>;
+    axisIdProp: ComputedRef<string>;
+    lineStackBasesMap: ComputedRef<Map<string, number[]> | undefined>;
+    lineTransformedValues: ComputedRef<Map<string, number[]> | undefined>;
+    rangeGroups: ComputedRef<Map<string, {
+        datasetIds: string[];
+        color?: ColorValue;
+        fillOpacity: number;
+    }> | undefined>;
+    features: ComputedRef<Map<FeatureType, {
+        type: FeatureType;
+        props: AnyFeatureProps;
+    }>>;
+    labelConfig?: ComputedRef<FrameDataLabelConfig | null>;
+    layoutData?: ComputedRef<CartesianLayoutData | null>;
+    compositor?: CanvasCompositorLike;
+    dir: Ref<'ltr' | 'rtl'>;
+    /** Reactive theme — read via `.value` inside the composable. */
+    theme: ComputedRef<Required<ChartTheme>>;
+}
+export interface UseLineRendererResult {
+    groupRef: Ref<SVGGElement | null>;
+    hitTest: (x: number, y: number) => LineHitTestResult | null;
+    findAllNearest: (x: number, y: number) => {
+        primary: CartesianHitTestResult;
+        allSeries: CrosshairSeriesHit[];
+    } | null;
+    hasLineData: ComputedRef<boolean>;
+    lineLayouts: ShallowRef<Map<string, LineRenderData>>;
+    lineRenderProps: ShallowRef<Map<string, LineRenderProps<unknown>>>;
+    /**
+     * Subscribe to per-frame tip-position updates. Returns unsubscribe.
+     * Callback receives the current `datasetId → {x, y}` map during tip-extension
+     * animation, or `null` when no animation is in flight or when it completes.
+     */
+    subscribeTipPositions: (cb: (positions: Map<string, {
+        x: number;
+        y: number;
+    }> | null) => void) => () => void;
+    markerOverlays: Ref<MarkerOverlayEntry[]>;
+    syncWithAnimatedScale: (categoryScale: BandScale, valueScales?: Map<string, LinearScale>) => void;
+    applyPropertyAnimations: (store: AnimatedPropertyStoreLike) => void;
+    renderFrameCycle: () => void;
+}

package/dist/types/pie.types.d.ts

@@ -0,0 +1,49 @@
+import type { AnimatedPropertyStoreLike, AnyFeatureProps, BoxArea, ChartTheme, DatasetRegistration, FeatureType, PieProps, RadialHitTestResult } from '@primeui/chart-types';
+import type { ComputedRef, Ref, VNode } from 'vue';
+export type ChartPieProps<T = unknown> = PieProps<T, VNode | null>;
+export interface UsePieRendererOptions {
+    chartArea: Ref<BoxArea>;
+    renderer: 'svg' | 'canvas';
+    canvasEl: Ref<HTMLCanvasElement | null>;
+    containerEl: Ref<HTMLDivElement | null>;
+    datasets: Ref<Map<string, DatasetRegistration>>;
+    features: Ref<Map<FeatureType, {
+        type: FeatureType;
+        props: AnyFeatureProps;
+    }>>;
+    hover: Ref<{
+        datasetId: string | null;
+        index: number | null;
+    }>;
+    datasetVisibility: Ref<Map<string, boolean>>;
+    hiddenItems: Ref<Map<string, Set<number>>>;
+    chartId: string;
+    width: Ref<number>;
+    height: Ref<number>;
+    globalFont?: {
+        family?: string;
+        size?: number;
+    };
+    adaptiveDataLabelFontSize?: Ref<number | undefined>;
+    dir: Ref<'ltr' | 'rtl'>;
+    /** Reactive theme — read via `.value` inside the composable. */
+    theme: ComputedRef<Required<ChartTheme>>;
+}
+export interface UsePieRendererResult {
+    groupRef: Ref<SVGGElement | null>;
+    labelGroupRef: Ref<SVGGElement | null>;
+    hitTest: (x: number, y: number) => RadialHitTestResult | null;
+    getSlicePosition: (datasetId: string, index: number) => {
+        x: number;
+        y: number;
+    } | null;
+    center: Ref<{
+        x: number;
+        y: number;
+    } | null>;
+    svgContent: Ref<VNode[]>;
+    /** Forwards animated property values to the controller for the current frame. */
+    applyPropertyAnimations: (store: AnimatedPropertyStoreLike) => void;
+    /** Triggers a full re-render so SVG attributes restore to base values when a property animation completes. */
+    renderFrameCycle: () => void;
+}

package/dist/types/polar.types.d.ts

@@ -0,0 +1,63 @@
+import type { AnimatedPropertyStoreLike, AxisConfig, AnyFeatureProps, BoxArea, ChartTheme, CrosshairSeriesHit, DatasetRegistration, FeatureType, PolarProps, PolarRenderData, RadialHitTestResult } from '@primeui/chart-types';
+import type { ComputedRef, Ref, ShallowRef } from 'vue';
+export type ChartPolarProps<T = unknown> = PolarProps<T>;
+export interface UsePolarRendererOptions {
+    chartArea: ComputedRef<BoxArea | null>;
+    renderer: 'svg' | 'canvas';
+    canvasEl: Ref<HTMLCanvasElement | null> | ShallowRef<HTMLCanvasElement | null>;
+    datasets: ComputedRef<Map<string, DatasetRegistration>>;
+    features: ComputedRef<Map<FeatureType, {
+        type: FeatureType;
+        props: AnyFeatureProps;
+    }>>;
+    hover: ComputedRef<{
+        datasetId: string | null;
+        index: number | null;
+        axisIndex?: number | null;
+    }>;
+    datasetVisibility: ComputedRef<Map<string, boolean>>;
+    globalFont?: {
+        family?: string;
+        size?: number;
+    };
+    adaptiveDataLabelFontSize?: ComputedRef<number | undefined>;
+    chartId: string;
+    width: ComputedRef<number>;
+    height: ComputedRef<number>;
+    sharedContext?: ComputedRef<{
+        categories: string[];
+        domain: [number, number];
+    } | null>;
+    requestRedraw?: () => void;
+    dir: Ref<'ltr' | 'rtl'>;
+    xAxes?: ComputedRef<Map<string, AxisConfig>>;
+    yAxes?: ComputedRef<Map<string, AxisConfig>>;
+    /** Reactive theme — read via `.value` inside the composable. */
+    theme: ComputedRef<Required<ChartTheme>>;
+}
+export interface UsePolarRendererResult {
+    groupRef: Ref<SVGGElement | null>;
+    hitTest: (x: number, y: number) => RadialHitTestResult | null;
+    getPointPosition: (datasetId: string, index: number) => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        shape: 'circle';
+    } | null;
+    findAllNearest: (x: number, y: number) => {
+        primary: RadialHitTestResult;
+        allSeries: CrosshairSeriesHit[];
+    } | null;
+    active: ComputedRef<boolean>;
+    center: {
+        x: number;
+        y: number;
+    } | null;
+    layout: Ref<PolarRenderData | null>;
+    renderCanvasContent: (ctx: CanvasRenderingContext2D, canvas: HTMLCanvasElement) => void;
+    /** Forwards animated property values to the controller for the current frame. */
+    applyPropertyAnimations: (store: AnimatedPropertyStoreLike) => void;
+    /** Triggers a full re-render so SVG attributes restore to base values when a property animation completes. */
+    renderFrameCycle: () => void;
+}

package/dist/types/radar.types.d.ts

@@ -0,0 +1,56 @@
+import type { AnimatedPropertyStoreLike, AxisConfig, AnyFeatureProps, BoxArea, ChartTheme, CrosshairSeriesHit, DatasetRegistration, FeatureType, RadarDatasetEntry, RadarProps, RadarRenderData, RadialHitTestResult } from '@primeui/chart-types';
+import type { ComputedRef, Ref, ShallowRef, VNode } from 'vue';
+export type ChartRadarProps<T = unknown> = RadarProps<T, VNode | null>;
+export interface UseRadarRendererOptions {
+    chartArea: ComputedRef<BoxArea | null>;
+    renderer: 'svg' | 'canvas';
+    canvasEl: Ref<HTMLCanvasElement | null> | ShallowRef<HTMLCanvasElement | null>;
+    datasets: ComputedRef<Map<string, DatasetRegistration>>;
+    features: ComputedRef<Map<FeatureType, {
+        type: FeatureType;
+        props: AnyFeatureProps;
+    }>>;
+    hover: ComputedRef<{
+        datasetId: string | null;
+        index: number | null;
+        axisIndex?: number | null;
+    }>;
+    datasetVisibility: ComputedRef<Map<string, boolean>>;
+    globalFont?: {
+        family?: string;
+        size?: number;
+    };
+    adaptiveDataLabelFontSize?: ComputedRef<number | undefined>;
+    chartId: string;
+    width: ComputedRef<number>;
+    height: ComputedRef<number>;
+    sharedContext?: ComputedRef<{
+        categories: string[];
+        domain: [number, number];
+    } | null>;
+    requestRedraw?: () => void;
+    dir: Ref<'ltr' | 'rtl'>;
+    xAxes?: ComputedRef<Map<string, AxisConfig>>;
+    yAxes?: ComputedRef<Map<string, AxisConfig>>;
+    /** Reactive theme — read via `.value` inside the composable. */
+    theme: ComputedRef<Required<ChartTheme>>;
+}
+export interface UseRadarRendererResult {
+    groupRef: Ref<SVGGElement | null>;
+    hitTest: (x: number, y: number) => RadialHitTestResult | null;
+    findAllNearest: (x: number, y: number) => {
+        primary: RadialHitTestResult;
+        allSeries: CrosshairSeriesHit[];
+    } | null;
+    active: ComputedRef<boolean>;
+    markerData: Ref<{
+        layout: RadarRenderData;
+        entries: RadarDatasetEntry[];
+    } | null>;
+    layout: Ref<RadarRenderData | null>;
+    renderCanvasContent: (ctx: CanvasRenderingContext2D, canvas: HTMLCanvasElement) => void;
+    /** Forwards animated property values to the controller for the current frame. */
+    applyPropertyAnimations: (store: AnimatedPropertyStoreLike) => void;
+    /** Triggers a full re-render so SVG attributes restore to base values when a property animation completes. */
+    renderFrameCycle: () => void;
+}

package/dist/types/responsiveDimensions.types.d.ts

@@ -0,0 +1,16 @@
+import type { MaybeRef, Ref, ShallowRef } from 'vue';
+export interface UseResponsiveDimensionsOptions {
+    width: MaybeRef<number | undefined>;
+    height: MaybeRef<number | undefined>;
+    responsive: MaybeRef<boolean>;
+    debounceWithRAF?: boolean;
+    debounceDelay?: MaybeRef<number | undefined>;
+    aspectRatio?: MaybeRef<number | undefined>;
+    maxDimensions?: MaybeRef<boolean>;
+    onResize?: (width: number, height: number) => void;
+}
+export interface UseResponsiveDimensionsResult {
+    containerRef: ShallowRef<HTMLDivElement | null>;
+    width: Ref<number>;
+    height: Ref<number>;
+}

package/dist/types/scatter.types.d.ts

@@ -0,0 +1,50 @@
+import type { AnimatedPropertyStoreLike, BandScale, CanvasCompositorLike, AnyFeatureProps, BoxArea, ChartTheme, DatasetRegistration, DecimationAlgorithm, FeatureType, FrameDataLabelConfig, HoverConfig, LinearScale, MarkerOverlayEntry, ScatterHitTestResult, ScatterProps, ScatterRenderData, ZoomState } from '@primeui/chart-types';
+import type { ComputedRef, Ref, ShallowRef, VNode } from 'vue';
+export type ChartScatterProps<T = unknown> = ScatterProps<T, VNode | null>;
+export interface UseScatterRendererOptions {
+    chartArea: ComputedRef<BoxArea>;
+    renderer: 'svg' | 'canvas';
+    canvasEl: Ref<HTMLCanvasElement | null> | ShallowRef<HTMLCanvasElement | null>;
+    datasets: ComputedRef<Map<string, DatasetRegistration>>;
+    datasetVisibility: ComputedRef<Map<string, boolean>>;
+    hover: ComputedRef<{
+        datasetId: string | null;
+        index: number | null;
+    }>;
+    hoverConfig: ComputedRef<HoverConfig | undefined>;
+    chartId: string;
+    width: ComputedRef<number>;
+    height: ComputedRef<number>;
+    scatterXScales: ComputedRef<Map<string, LinearScale> | undefined>;
+    valueScales: ComputedRef<Map<string, LinearScale> | undefined>;
+    firstCategoryAxisId: ComputedRef<string>;
+    firstValueAxisId: ComputedRef<string>;
+    scatterStackBasesMap: ComputedRef<Map<string, number[]> | undefined>;
+    compositor?: CanvasCompositorLike;
+    decimationConfig?: ComputedRef<{
+        algorithm?: DecimationAlgorithm;
+        samples?: number;
+        threshold?: number;
+    } | undefined>;
+    zoomState?: ComputedRef<ZoomState | null>;
+    orientation?: ComputedRef<'vertical' | 'horizontal'>;
+    labelConfig?: ComputedRef<FrameDataLabelConfig | null>;
+    features: ComputedRef<Map<FeatureType, {
+        type: FeatureType;
+        props: AnyFeatureProps;
+    }>>;
+    dir: Ref<'ltr' | 'rtl'>;
+    /** Reactive theme — read via `.value` inside the composable. */
+    theme: ComputedRef<Required<ChartTheme>>;
+}
+export interface UseScatterRendererResult {
+    groupRef: Ref<SVGGElement | null>;
+    hitTest: (x: number, y: number) => ScatterHitTestResult | null;
+    hasScatterData: ComputedRef<boolean>;
+    boostActive: ComputedRef<boolean>;
+    scatterLayouts: Map<string, ScatterRenderData>;
+    markerOverlays: Ref<MarkerOverlayEntry[]>;
+    applyPropertyAnimations: (store: AnimatedPropertyStoreLike) => void;
+    renderFrameCycle: () => void;
+    syncWithAnimatedScale: (categoryScale: BandScale, valueScales?: Map<string, LinearScale>, valueXScales?: Map<string, LinearScale>) => void;
+}

package/dist/types/svg.types.d.ts

@@ -0,0 +1,44 @@
+import type { ChartAnimationProps, ChartContainerBaseProps, ChartPluginContext, ChartPluginExpose, ChartTheme } from '@primeui/chart-types';
+import type { CSSProperties } from 'vue';
+export type RendererHint = 'cartesian' | 'heatmap' | 'radial' | 'rect';
+/**
+ * A chart plugin definition (the result of `defineChartPlugin`). Structurally a
+ * `@primeui/core` Plugin whose install receives a {@link ChartPluginContext}.
+ * Declared locally (not imported from `@primeui/core`) to keep vue-chart's
+ * public type surface free of an undeclared cross-package dependency.
+ */
+export interface ChartPlugin<TOptions = unknown> {
+    /** Plugin name; keys the `$plugins[name]` binding. */
+    name?: string;
+    /** Install fn — receives the chart-filled context, returns the plugin's public API. */
+    install: (context: ChartPluginContext<TOptions>) => ChartPluginExpose | void | Promise<ChartPluginExpose | void>;
+}
+/**
+ * A single entry in the `plugins` prop: either a bare plugin or a
+ * `[plugin, options]` tuple — matching the `@primeui/core` install contract.
+ */
+export type ChartPluginEntry = ChartPlugin | [ChartPlugin, unknown];
+export interface ChartSvgProps extends Omit<ChartContainerBaseProps, 'width' | 'height'>, ChartAnimationProps {
+    /** Chart width in pixels (max width when responsive). */
+    width?: number;
+    /** Chart height in pixels (max height when responsive). */
+    height?: number;
+    /** Custom CSS class */
+    class?: string;
+    /** Custom inline styles */
+    style?: CSSProperties;
+    /**
+     * Theme overrides — series palette, chrome (axes, grid, labels), and effect coefficients.
+     * SVG: each set field expands to a `--p-chart-*` CSS variable on the chart container.
+     * Unset fields fall through to `@primeui/chart-style` token defaults.
+     */
+    theme?: ChartTheme;
+    /**
+     * Chart plugins (results of `defineChartPlugin`), each optionally paired with
+     * options as a `[plugin, options]` tuple. Plugins read chart state, subscribe
+     * to render frames/hover, and can paint an overlay layered above the chart.
+     * Their returned API is surfaced on `$plugins[name]` and the default slot's
+     * `plugins` binding.
+     */
+    plugins?: ChartPluginEntry[];
+}

package/dist/types/tooltip.types.d.ts

@@ -0,0 +1,6 @@
+import type { TooltipProps as CoreTooltipProps, TooltipRenderContext } from '@primeui/chart-types';
+import type { VNode } from 'vue';
+export interface ChartTooltipProps extends CoreTooltipProps {
+    /** Custom render function for tooltip content */
+    render?: (context: TooltipRenderContext) => VNode | VNode[] | string | null;
+}

package/dist/types/treemap.types.d.ts

@@ -0,0 +1,50 @@
+import type { AnimatedPropertyStoreLike, AnyFeatureProps, BoxArea, ChartTheme, ColorScaleInfo, DatasetRegistration, FeatureType, RadialHitTestResult, TreemapCellContext, TreemapGroupProps, TreemapProps } from '@primeui/chart-types';
+import type { ComputedRef, Ref, ShallowRef, VNode } from 'vue';
+import type { DrilldownStateResult } from './chart.types';
+export type ChartTreemapProps<T = unknown> = TreemapProps<T, VNode | null>;
+export type { TreemapCellContext, TreemapGroupProps };
+export interface UseTreemapRendererOptions {
+    chartArea: ComputedRef<BoxArea>;
+    renderer: 'svg' | 'canvas';
+    canvasEl: Ref<HTMLCanvasElement | null> | ShallowRef<HTMLCanvasElement | null>;
+    datasets: ComputedRef<Map<string, DatasetRegistration>>;
+    features: ComputedRef<Map<FeatureType, {
+        type: FeatureType;
+        props: AnyFeatureProps;
+    }>>;
+    hover: ComputedRef<{
+        datasetId: string | null;
+        index: number | null;
+    }>;
+    datasetVisibility: ComputedRef<Map<string, boolean>>;
+    width: ComputedRef<number>;
+    height: ComputedRef<number>;
+    chartId: string;
+    drilldownState: DrilldownStateResult;
+    globalFont?: {
+        family?: string;
+        size?: number;
+    };
+    /** Reactive theme — read via `.value` inside the composable. Treemap doesn't currently use theme.series, but the option is here for consistency. */
+    theme: ComputedRef<Required<ChartTheme>>;
+}
+export interface UseTreemapRendererResult {
+    wrapperRef: Ref<SVGGElement | null>;
+    groupRef: Ref<SVGGElement | null>;
+    overlayRef: Ref<SVGGElement | null>;
+    svgContent: ComputedRef<VNode[]>;
+    hitTest: (x: number, y: number) => RadialHitTestResult | null;
+    getPointPosition: (datasetId: string, index: number) => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        shape: 'rect';
+    } | null;
+    handleDrilldownClick: (hit: RadialHitTestResult) => boolean;
+    prepareDrillOut: () => void;
+    updateHoverOverlay: (hit: RadialHitTestResult | null) => void;
+    getColorScaleInfo: () => ColorScaleInfo | null;
+    applyPropertyAnimations: (store: AnimatedPropertyStoreLike) => void;
+    renderFrameCycle: () => void;
+}

package/dist/types/zoom.types.d.ts

@@ -0,0 +1,45 @@
+import type { BoxArea, LinearScale, ZoomProps, ZoomState } from '@primeui/chart-types';
+import type { Ref, ShallowRef } from 'vue';
+export interface UseZoomPanOptions {
+    /** Zoom config from <ChartZoom> (null if no zoom component) */
+    zoomConfig: Ref<ZoomProps | null>;
+    /** Ref to the chart container div */
+    containerRef: Ref<HTMLDivElement | null>;
+    /** Get the current plot area (cartesian area) */
+    getPlotArea: () => BoxArea | null;
+    /** Get current scales for inversion (pixel → data) */
+    getScales: () => {
+        x?: LinearScale;
+        y?: LinearScale;
+    } | null;
+    /** Get the original (pre-zoom) domains for limit resolution */
+    getOriginalDomains: () => {
+        x?: [number, number];
+        y?: [number, number];
+        minRangeX?: number;
+        minRangeY?: number;
+    };
+    /** Whether the chart is cartesian */
+    isCartesian: Ref<boolean>;
+}
+export interface UseZoomPanResult {
+    /** Current zoom state (reactive) */
+    zoomState: ShallowRef<ZoomState>;
+    /** Reset to original view */
+    resetZoom: () => void;
+    /** Programmatic zoom update — immediately settles state + fires onZoomChange */
+    updateZoom: (state: ZoomState) => void;
+    /** Read current zoom state (always up-to-date, never stale) */
+    getZoomState: () => ZoomState;
+    /** Whether the chart is zoomed or panned (reactive) */
+    isZoomed: Ref<boolean>;
+    /** Whether a drag/pan gesture is in progress (reactive) */
+    isDragging: Ref<boolean>;
+    /** Selection rect during drag-to-zoom (reactive, null when not dragging) */
+    selectionRect: Ref<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { normalizeDataLabelConfig } from '@primeui/chart-core';
+export type { DataLabelConfig } from '@primeui/chart-core';
+export { LEGEND_ITEM_BASE_STYLE, LEGEND_SWATCH_STYLE, TOOLTIP_BASE_STYLE, TOOLTIP_DEFAULT_STYLE, TOOLTIP_COLOR_INDICATOR_STYLE } from './styles';

package/dist/utils/styles.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Re-export shared style constants from chart-core.
+ * Cast to CSSProperties for Vue type compatibility.
+ */
+import type { CSSProperties } from 'vue';
+export declare const LEGEND_ITEM_BASE_STYLE: CSSProperties;
+export declare const LEGEND_SWATCH_STYLE: CSSProperties;
+export declare const TOOLTIP_BASE_STYLE: CSSProperties;
+export declare const TOOLTIP_DEFAULT_STYLE: CSSProperties;
+export declare const TOOLTIP_COLOR_INDICATOR_STYLE: CSSProperties;

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@primeui/vue-chart",
+  "version": "0.0.1-alpha.1",
+  "author": "PrimeTek Informatics",
+  "description": "Vue Chart component for PrimeUI.",
+  "keywords": [
+    "chart",
+    "primeui"
+  ],
+  "license": "SEE LICENSE IN LICENSE.md",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/primefaces/primeui.git",
+    "directory": "packages/components/chart/vue-chart"
+  },
+  "bugs": {
+    "url": "https://github.com/primefaces/primeui/issues"
+  },
+  "main": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./namespace": {
+      "types": "./dist/namespace.d.mts",
+      "import": "./dist/namespace.mjs",
+      "default": "./dist/namespace.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@primeui/license-manager": "^1.0.0-alpha.1",
+    "@primeui/chart-core": "0.0.1-alpha.1",
+    "@primeui/chart-types": "0.0.1-alpha.1"
+  },
+  "peerDependencies": {
+    "vue": "^3.5"
+  },
+  "devDependencies": {
+    "unplugin-vue": "^7.2.0"
+  },
+  "scripts": {
+    "build": "cross-env NODE_ENV=production INPUT_DIR=src/ OUTPUT_DIR=dist/ pnpm run build:package",
+    "build:dev": "cross-env NODE_ENV=development INPUT_DIR=src/ OUTPUT_DIR=dist/ pnpm run build:dev:package",
+    "build:package": "cross-env NODE_ENV=test pnpm run test && tsup && vue-tsc -p tsconfig.build.json",
+    "build:dev:package": "tsup --watch",
+    "test": "vitest run --root ../../../.. vue-chart --passWithNoTests",
+    "type:check": "vue-tsc --noEmit",
+    "dev:link": "pnpm link --global && npm link"
+  },
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts"
+}