@primeui/vue-chart 0.0.1-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+export { default as ChartCanvas } from './ChartCanvas.vue';
+export { default as ChartSvg } from './ChartSvg.vue';
+export { default as ChartBar } from './components/charts/ChartBar.vue';
+export { default as ChartCandlestick } from './components/charts/ChartCandlestick.vue';
+export { default as ChartHeatmap } from './components/charts/ChartHeatmap.vue';
+export { default as ChartLine } from './components/charts/ChartLine.vue';
+export { default as ChartPie } from './components/charts/ChartPie.vue';
+export { default as ChartPolar } from './components/charts/ChartPolar.vue';
+export { default as ChartRadar } from './components/charts/ChartRadar.vue';
+export { default as ChartScatter } from './components/charts/ChartScatter.vue';
+export { default as ChartTreemap } from './components/charts/ChartTreemap.vue';
+export { default as ChartItem } from './components/items/ChartItem.vue';
+export { default as ChartTreemapGroup } from './components/items/ChartTreemapGroup.vue';
+export { default as ChartAccessibility } from './components/customizations/ChartAccessibility.vue';
+export { default as ChartAnnotation } from './components/customizations/ChartAnnotation.vue';
+export { default as ChartAxisCategory } from './components/customizations/ChartAxisCategory.vue';
+export { default as ChartAxisGroup } from './components/customizations/ChartAxisGroup.vue';
+export { default as ChartBreadcrumb } from './components/customizations/ChartBreadcrumb.vue';
+export { default as ChartCaption } from './components/customizations/ChartCaption.vue';
+export { default as ChartColorLegend } from './components/customizations/ChartColorLegend.vue';
+export { default as ChartDataLabels } from './components/customizations/ChartDataLabels.vue';
+export { default as ChartExportMenu } from './components/customizations/ChartExportMenu.vue';
+export { default as ChartHover } from './components/customizations/ChartHover.vue';
+export { default as ChartLegend } from './components/customizations/ChartLegend.vue';
+export { default as ChartNavigator } from './components/customizations/ChartNavigator.vue';
+export { default as ChartReferenceBand } from './components/customizations/ChartReferenceBand.vue';
+export { default as ChartReferenceLine } from './components/customizations/ChartReferenceLine.vue';
+export { default as ChartResponsive } from './components/customizations/ChartResponsive.vue';
+export { default as ChartTitle } from './components/customizations/ChartTitle.vue';
+export { default as ChartTooltip } from './components/customizations/ChartTooltip.vue';
+export { default as ChartXAxis } from './components/customizations/ChartXAxis.vue';
+export { default as ChartYAxis } from './components/customizations/ChartYAxis.vue';
+export { default as ChartZoom } from './components/customizations/ChartZoom.vue';
+export { default as ChartDecimation } from './components/containers/ChartDecimation.vue';
+export { default as ChartGroup } from './components/containers/ChartGroup.vue';
+export { default as ChartOverlap } from './components/containers/ChartOverlap.vue';
+export { default as ChartRange } from './components/containers/ChartRange.vue';
+export { default as ChartStacked } from './components/containers/ChartStacked.vue';
+export { default as ChartWaterfall } from './components/containers/ChartWaterfall.vue';
+export type { Alignment, AnnotationContext, AxisTickMarkRenderContext, AxisTickRenderContext, BarShapeFunction, BarShapeInfo, BorderRadius, ChartBarProps, ChartCandlestickProps, ChartCaptionProps, ChartHeatmapProps, ChartItemProps, ChartLegendProps, ChartLineProps, ChartPieProps, ChartPolarProps, ChartRadarProps, ChartScatterProps, ChartSvgProps, ChartTooltipProps, ChartTreemapProps, ColorScaleInfo, ColorValue, DataLabelContext, DecimationAlgorithm, DrilldownStateResult, EasingFunctionName, FieldAccessor, GradientColor, GradientStop, HeatmapCellContext, HeatmapHitTestResult, HoverProps, ItemCollectorContextValue, ItemContext, LegendItemRenderContext, LegendProps, LinearGradientConfig, PointDescriptionContext, RadialGradient, RadialHitTestResult, ResolvedSyncConfig, ResponsiveRule, SegmentContext, SeriesType, SliceRenderContext, SyncConfig, TickStyle, TickValue, TooltipItem, TooltipRenderContext, TooltipRow, TooltipState, TreemapCellContext, TreemapGroupProps, UseChartSyncOptions, UseChartSyncResult, UseDatasetRegistrationOptions, UseItemCollectorResult, ZoomAxisWindow, ZoomHandle, ZoomState } from './types';
+export { useChartHover, useChartMethods, useChartState } from './context';
+export { useChartSync, useDatasetRegistration, useDrilldownState, useItemCollector } from './composables';
+export type { PointRenderContext } from '@primeui/chart-core';
+export { easings, getEasing, registerEasing } from '@primeui/chart-core';

package/dist/index.mjs

@@ -0,0 +1,67 @@
+export { ChartBar_default as ChartBar } from './chunk-K326BBF7.mjs';
+export { ChartTreemap_default as ChartTreemap } from './chunk-2D3PWFR2.mjs';
+export { ChartScatter_default as ChartScatter } from './chunk-5DWO3G33.mjs';
+export { ChartRadar_default as ChartRadar } from './chunk-E2U4W5FW.mjs';
+export { ChartPolar_default as ChartPolar } from './chunk-AAX7FOW3.mjs';
+export { ChartPie_default as ChartPie } from './chunk-ZHFL3RYO.mjs';
+export { ChartLine_default as ChartLine } from './chunk-644ROAHU.mjs';
+export { ChartHeatmap_default as ChartHeatmap } from './chunk-DLUFOM5K.mjs';
+export { ChartCandlestick_default as ChartCandlestick } from './chunk-WKSQR6L5.mjs';
+export { ChartAnnotation_default as ChartAnnotation } from './chunk-ZNINPVG7.mjs';
+export { ChartAccessibility_default as ChartAccessibility } from './chunk-O6L3PNFC.mjs';
+export { ChartWaterfall_default as ChartWaterfall } from './chunk-W5M3BR6N.mjs';
+export { ChartStacked_default as ChartStacked } from './chunk-TIV2FI4S.mjs';
+export { ChartRange_default as ChartRange } from './chunk-RQURY2H3.mjs';
+export { ChartOverlap_default as ChartOverlap } from './chunk-GA4VV5V4.mjs';
+export { ChartGroup_default as ChartGroup } from './chunk-PJVOZSPF.mjs';
+export { ChartDecimation_default as ChartDecimation } from './chunk-RSAZ7V5Z.mjs';
+export { ChartHover_default as ChartHover } from './chunk-RSTIA3KM.mjs';
+export { ChartExportMenu_default as ChartExportMenu } from './chunk-GFC24374.mjs';
+export { ChartDataLabels_default as ChartDataLabels } from './chunk-CDXF6ZTL.mjs';
+export { ChartColorLegend_default as ChartColorLegend } from './chunk-WYV2MHP6.mjs';
+export { ChartCaption_default as ChartCaption } from './chunk-4THCGGER.mjs';
+export { ChartBreadcrumb_default as ChartBreadcrumb } from './chunk-62NGBLQ7.mjs';
+export { ChartAxisGroup_default as ChartAxisGroup } from './chunk-WA735Y26.mjs';
+export { ChartAxisCategory_default as ChartAxisCategory } from './chunk-FQTWLAVA.mjs';
+export { ChartXAxis_default as ChartXAxis } from './chunk-32XIRBZ7.mjs';
+export { ChartTooltip_default as ChartTooltip } from './chunk-YGHWUR7K.mjs';
+export { ChartTitle_default as ChartTitle } from './chunk-6S4JMPKC.mjs';
+export { ChartResponsive_default as ChartResponsive } from './chunk-J2P5JBHC.mjs';
+export { ChartReferenceLine_default as ChartReferenceLine } from './chunk-42J32DPD.mjs';
+export { ChartReferenceBand_default as ChartReferenceBand } from './chunk-4UVPCLJ7.mjs';
+export { ChartNavigator_default as ChartNavigator } from './chunk-56NMBNNX.mjs';
+export { ChartLegend_default as ChartLegend } from './chunk-PSSXPTLQ.mjs';
+import './chunk-54DLUFIA.mjs';
+import './chunk-FFBK7Q3W.mjs';
+import './chunk-RRHYGSK6.mjs';
+import './chunk-MDA22SIZ.mjs';
+import './chunk-YRKAI2R2.mjs';
+export { ChartTreemapGroup_default as ChartTreemapGroup } from './chunk-AUI5R4DA.mjs';
+export { ChartItem_default as ChartItem } from './chunk-KOWFD2AE.mjs';
+export { ChartZoom_default as ChartZoom } from './chunk-ZRCOVQQM.mjs';
+export { ChartYAxis_default as ChartYAxis } from './chunk-XBDNMPF7.mjs';
+import './chunk-5SRBQVU5.mjs';
+import './chunk-HTZVV6VV.mjs';
+import './chunk-DYVFVVTO.mjs';
+import './chunk-DOOXGOOB.mjs';
+import './chunk-JKK3D33U.mjs';
+import './chunk-UO27BCRL.mjs';
+import './chunk-4CRHCZV3.mjs';
+export { ChartSvg_default as ChartSvg } from './chunk-44BAFHPK.mjs';
+export { ChartCanvas_default as ChartCanvas } from './chunk-72KINEJ6.mjs';
+import './chunk-372K2BMN.mjs';
+import './chunk-5FTUGKPC.mjs';
+import './chunk-E4ROAOPT.mjs';
+import './chunk-GX2MK6VT.mjs';
+import './chunk-VWABO23U.mjs';
+import './chunk-4NJ2PSHV.mjs';
+export { useChartSync, useDatasetRegistration, useDrilldownState, useItemCollector } from './chunk-CQHNYT2V.mjs';
+import './chunk-TEOO4OLV.mjs';
+import './chunk-PQV55JYI.mjs';
+import './chunk-J43KLCZF.mjs';
+import './chunk-NLXOJSKK.mjs';
+export { useChartHover, useChartMethods, useChartState } from './chunk-HANSF33Z.mjs';
+import './chunk-LD57I4SY.mjs';
+import './chunk-FZ3PZ66C.mjs';
+import './chunk-7P6ASYW6.mjs';
+export { easings, getEasing, registerEasing } from '@primeui/chart-core';

package/dist/namespace.d.ts

@@ -0,0 +1 @@
+export * as Chart from './Chart.parts';

package/dist/namespace.mjs

@@ -0,0 +1,112 @@
+import { ChartBar_default } from './chunk-K326BBF7.mjs';
+import { ChartTreemap_default } from './chunk-2D3PWFR2.mjs';
+import { ChartScatter_default } from './chunk-5DWO3G33.mjs';
+import { ChartRadar_default } from './chunk-E2U4W5FW.mjs';
+import { ChartPolar_default } from './chunk-AAX7FOW3.mjs';
+import { ChartPie_default } from './chunk-ZHFL3RYO.mjs';
+import { ChartLine_default } from './chunk-644ROAHU.mjs';
+import { ChartHeatmap_default } from './chunk-DLUFOM5K.mjs';
+import { ChartCandlestick_default } from './chunk-WKSQR6L5.mjs';
+import { ChartAnnotation_default } from './chunk-ZNINPVG7.mjs';
+import { ChartAccessibility_default } from './chunk-O6L3PNFC.mjs';
+import { ChartWaterfall_default } from './chunk-W5M3BR6N.mjs';
+import { ChartStacked_default } from './chunk-TIV2FI4S.mjs';
+import { ChartRange_default } from './chunk-RQURY2H3.mjs';
+import { ChartOverlap_default } from './chunk-GA4VV5V4.mjs';
+import { ChartGroup_default } from './chunk-PJVOZSPF.mjs';
+import { ChartDecimation_default } from './chunk-RSAZ7V5Z.mjs';
+import { ChartHover_default } from './chunk-RSTIA3KM.mjs';
+import { ChartExportMenu_default } from './chunk-GFC24374.mjs';
+import { ChartDataLabels_default } from './chunk-CDXF6ZTL.mjs';
+import { ChartColorLegend_default } from './chunk-WYV2MHP6.mjs';
+import { ChartCaption_default } from './chunk-4THCGGER.mjs';
+import { ChartBreadcrumb_default } from './chunk-62NGBLQ7.mjs';
+import { ChartAxisGroup_default } from './chunk-WA735Y26.mjs';
+import { ChartAxisCategory_default } from './chunk-FQTWLAVA.mjs';
+import { ChartXAxis_default } from './chunk-32XIRBZ7.mjs';
+import { ChartTooltip_default } from './chunk-YGHWUR7K.mjs';
+import { ChartTitle_default } from './chunk-6S4JMPKC.mjs';
+import { ChartResponsive_default } from './chunk-J2P5JBHC.mjs';
+import { ChartReferenceLine_default } from './chunk-42J32DPD.mjs';
+import { ChartReferenceBand_default } from './chunk-4UVPCLJ7.mjs';
+import { ChartNavigator_default } from './chunk-56NMBNNX.mjs';
+import { ChartLegend_default } from './chunk-PSSXPTLQ.mjs';
+import './chunk-54DLUFIA.mjs';
+import './chunk-FFBK7Q3W.mjs';
+import './chunk-RRHYGSK6.mjs';
+import './chunk-MDA22SIZ.mjs';
+import './chunk-YRKAI2R2.mjs';
+import { ChartTreemapGroup_default } from './chunk-AUI5R4DA.mjs';
+import { ChartItem_default } from './chunk-KOWFD2AE.mjs';
+import { ChartZoom_default } from './chunk-ZRCOVQQM.mjs';
+import { ChartYAxis_default } from './chunk-XBDNMPF7.mjs';
+import './chunk-5SRBQVU5.mjs';
+import './chunk-HTZVV6VV.mjs';
+import './chunk-DYVFVVTO.mjs';
+import './chunk-DOOXGOOB.mjs';
+import './chunk-JKK3D33U.mjs';
+import './chunk-UO27BCRL.mjs';
+import './chunk-4CRHCZV3.mjs';
+import { ChartSvg_default } from './chunk-44BAFHPK.mjs';
+import { ChartCanvas_default } from './chunk-72KINEJ6.mjs';
+import './chunk-372K2BMN.mjs';
+import './chunk-5FTUGKPC.mjs';
+import './chunk-E4ROAOPT.mjs';
+import './chunk-GX2MK6VT.mjs';
+import './chunk-VWABO23U.mjs';
+import './chunk-4NJ2PSHV.mjs';
+import './chunk-CQHNYT2V.mjs';
+import './chunk-TEOO4OLV.mjs';
+import './chunk-PQV55JYI.mjs';
+import './chunk-J43KLCZF.mjs';
+import './chunk-NLXOJSKK.mjs';
+import './chunk-HANSF33Z.mjs';
+import './chunk-LD57I4SY.mjs';
+import './chunk-FZ3PZ66C.mjs';
+import { __export } from './chunk-7P6ASYW6.mjs';
+
+// src/Chart.parts.ts
+var Chart_parts_exports = {};
+__export(Chart_parts_exports, {
+  Accessibility: () => ChartAccessibility_default,
+  Annotation: () => ChartAnnotation_default,
+  AxisCategory: () => ChartAxisCategory_default,
+  AxisGroup: () => ChartAxisGroup_default,
+  Bar: () => ChartBar_default,
+  Breadcrumb: () => ChartBreadcrumb_default,
+  Candlestick: () => ChartCandlestick_default,
+  Canvas: () => ChartCanvas_default,
+  Caption: () => ChartCaption_default,
+  ColorLegend: () => ChartColorLegend_default,
+  DataLabels: () => ChartDataLabels_default,
+  Decimation: () => ChartDecimation_default,
+  ExportMenu: () => ChartExportMenu_default,
+  Group: () => ChartGroup_default,
+  Heatmap: () => ChartHeatmap_default,
+  Hover: () => ChartHover_default,
+  Item: () => ChartItem_default,
+  Legend: () => ChartLegend_default,
+  Line: () => ChartLine_default,
+  Navigator: () => ChartNavigator_default,
+  Overlap: () => ChartOverlap_default,
+  Pie: () => ChartPie_default,
+  Polar: () => ChartPolar_default,
+  Radar: () => ChartRadar_default,
+  Range: () => ChartRange_default,
+  ReferenceBand: () => ChartReferenceBand_default,
+  ReferenceLine: () => ChartReferenceLine_default,
+  Responsive: () => ChartResponsive_default,
+  Scatter: () => ChartScatter_default,
+  Stacked: () => ChartStacked_default,
+  Svg: () => ChartSvg_default,
+  Title: () => ChartTitle_default,
+  Tooltip: () => ChartTooltip_default,
+  Treemap: () => ChartTreemap_default,
+  TreemapGroup: () => ChartTreemapGroup_default,
+  Waterfall: () => ChartWaterfall_default,
+  XAxis: () => ChartXAxis_default,
+  YAxis: () => ChartYAxis_default,
+  Zoom: () => ChartZoom_default
+});
+
+export { Chart_parts_exports as Chart };

package/dist/release-date.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Release date of this specific version of @primeui/vue-chart.
+ *
+ * Passed to the license verifier so perpetual licenses are enforced against
+ * version dates: a license whose `update_ends_at` is earlier than this date
+ * does not cover the installed version.
+ *
+ * Kept as a literal for now. A build script should generate this file from the
+ * package's git tag / publish date going forward (mirrors the texteditor model).
+ */
+export declare const RELEASE_DATE = "2026-06-20";

package/dist/types/animation.types.d.ts

@@ -0,0 +1,38 @@
+import type { AnyFeatureProps, AnimatedPropertyStoreLike, CartesianAnimationOptionsBase, CartesianLayoutData, CustomMarkerEntry, FeatureType, PropertyAnimationConfig } from '@primeui/chart-types';
+import type { ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
+export interface UseCartesianAnimationOptions extends CartesianAnimationOptionsBase {
+    layoutData: ComputedRef<CartesianLayoutData | null>;
+    canvasEl: Ref<HTMLCanvasElement | null>;
+    /** Overlay canvas for animated custom markers (canvas mode only) */
+    overlayCanvasEl?: Ref<HTMLCanvasElement | null>;
+    /** Marker overlay entries from useLineRenderer — updated each animation frame */
+    markerOverlays?: Ref<CustomMarkerEntry[]>;
+    groupRef: Ref<SVGGElement | null>;
+    gridGroupRef: Ref<SVGGElement | null>;
+    hover: ComputedRef<{
+        datasetId: string | null;
+        index: number | null;
+    }>;
+    features: ComputedRef<Map<FeatureType, {
+        type: FeatureType;
+        props: AnyFeatureProps;
+    }>>;
+    width: ComputedRef<number>;
+    height: ComputedRef<number>;
+    /** Reactive dir ref — `.value` is read each frame so direction changes flow through. */
+    dir?: Ref<'ltr' | 'rtl'>;
+    /** When true, skip full chrome repaint on hover change (e.g. scatter boost mode where hover has no visual effect). */
+    skipHoverRepaint?: ComputedRef<boolean>;
+    /** True when any axis is zoomed — threaded into FrameContext for chart-core renderers that need it (e.g. axis labels that hide under zoom). */
+    isZoomed?: ComputedRef<boolean>;
+    /** Refs to custom tick overlay <g> elements — used by chart-core to apply axis opacity transitions */
+    customTickOverlayRefs?: Map<string, SVGGElement | null>;
+    /** Property animation configs — reactive so the chart-root `animations` prop and per-dataset configs can register after setup */
+    propertyAnimations?: MaybeRefOrGetter<PropertyAnimationConfig[] | undefined>;
+    /** Shared store for animated property values — hoisted from CartesianRenderer so renderers can read it */
+    animStoreRef?: ShallowRef<AnimatedPropertyStoreLike | null>;
+    /** Called on each registry tick — increments animVersion in CartesianRenderer to trigger re-render */
+    onAnimFrame?: () => void;
+    /** Called when a non-looping property animation completes (after store entry is deleted) — used to restore base SVG attribute values via renderFrameCycle. */
+    onPropertyComplete?: (storeKey: string) => void;
+}

package/dist/types/axes.types.d.ts

@@ -0,0 +1,27 @@
+import type { AxisGroupDefinition, AxisGroupRenderContext, AxisTickMarkRenderContext, AxisTickRenderContext, BaseAxisProps as CoreBaseAxisProps } from '@primeui/chart-types';
+import type { VNode } from 'vue';
+export interface ChartXAxisProps extends SharedAxisProps {
+    id?: string;
+    position?: 'top' | 'bottom';
+}
+export interface ChartYAxisProps extends SharedAxisProps {
+    id?: string;
+    position?: 'left' | 'right';
+}
+/** All props shared between ChartXAxis and ChartYAxis. */
+export interface SharedAxisProps extends CoreBaseAxisProps {
+    /** Shared between XAxis ('top'|'bottom') and YAxis ('left'|'right') */
+    position?: string;
+    /**
+     * Custom tick-label renderer. **SVG mode:** return a `VNode`. **Canvas mode:** `context.ctx`
+     * is a `CanvasRenderingContext2D` — draw imperatively and return nothing (`void`); the return
+     * value is ignored. (Returning a `VNode` on canvas renders nothing.)
+     */
+    render?: (context: AxisTickRenderContext) => VNode | null | void;
+    /** Custom tick-mark renderer. Same dual SVG-VNode / canvas-`ctx` contract as `render`. */
+    renderTick?: (context: AxisTickMarkRenderContext) => VNode | null | void;
+}
+export interface ChartAxisGroupProps extends Omit<AxisGroupDefinition, 'render' | 'categories' | 'depth'> {
+    /** Custom render function for the group label area */
+    render?: (context: AxisGroupRenderContext) => VNode | null;
+}

package/dist/types/axisComponentBase.types.d.ts

@@ -0,0 +1,5 @@
+import type { AxisGroupCollectorValue } from '@primeui/chart-types';
+export interface UseAxisComponentBaseResult {
+    /** Collector for AxisGroup children to register into */
+    groupCollector: AxisGroupCollectorValue;
+}

package/dist/types/axisGroup.types.d.ts

@@ -0,0 +1 @@
+export type { AxisCategoryCollector, ChartAxisCategoryProps } from '@primeui/chart-types';

package/dist/types/bar.types.d.ts

@@ -0,0 +1,42 @@
+import type { AnimatedPropertyStoreLike, CanvasCompositorLike, AnyFeatureProps, BarRenderData, BarRenderProps, BoxArea, CartesianHitTestResult, CartesianLayoutData, ChartTheme, BarProps as CoreBarProps, CrosshairSeriesHit, DatasetRegistration, FeatureType, FrameDataLabelConfig, HoverConfig } from '@primeui/chart-types';
+import type { ComputedRef, Ref, ShallowRef } from 'vue';
+export type ChartBarProps<T = unknown> = CoreBarProps<T>;
+export interface UseBarRendererOptions {
+    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>;
+    compositor?: CanvasCompositorLike;
+    layoutData: ComputedRef<CartesianLayoutData | null>;
+    features: ComputedRef<Map<FeatureType, {
+        type: FeatureType;
+        props: AnyFeatureProps;
+    }>>;
+    labelConfig?: ComputedRef<FrameDataLabelConfig | null>;
+    isZoomed?: ComputedRef<boolean>;
+    dir: Ref<'ltr' | 'rtl'>;
+    theme: ComputedRef<Required<ChartTheme>>;
+}
+export interface UseBarRendererResult {
+    groupRef: Ref<SVGGElement | null>;
+    hitTest: (x: number, y: number) => CartesianHitTestResult | null;
+    findNearest: (x: number, y: number) => CartesianHitTestResult | null;
+    findAllNearest: (x: number, y: number) => {
+        primary: CartesianHitTestResult;
+        allSeries: CrosshairSeriesHit[];
+    } | null;
+    hasBarData: ComputedRef<boolean>;
+    barLayouts: Map<string, BarRenderData>;
+    barRenderProps: Map<string, BarRenderProps<unknown>>;
+    applyPropertyAnimations: (store: AnimatedPropertyStoreLike) => void;
+    renderFrameCycle: () => void;
+}

package/dist/types/breadcrumb.types.d.ts

@@ -0,0 +1,12 @@
+import type { BreadcrumbItemContext, BreadcrumbProps as CoreBreadcrumbProps } from '@primeui/chart-types';
+import type { CSSProperties, VNode } from 'vue';
+export interface BreadcrumbProps extends Omit<CoreBreadcrumbProps, 'separator' | 'renderItem'> {
+    /** Custom separator between breadcrumb items. Default: ' / ' */
+    separator?: VNode | string;
+    /** Custom render function for each breadcrumb item */
+    renderItem?: (context: BreadcrumbItemContext) => VNode | null | void;
+    /** CSS class name for the breadcrumb container */
+    class?: string;
+    /** Inline styles for the breadcrumb container */
+    style?: CSSProperties;
+}

package/dist/types/candlestick.types.d.ts

@@ -0,0 +1,41 @@
+import type { AnimatedPropertyStoreLike, AnyFeatureProps, CanvasCompositorLike, BandScale, BoxArea, CandlestickHitTestResult, CandlestickProps, CandlestickRenderData, CartesianHitTestResult, CartesianLayoutData, ChartTheme, CrosshairSeriesHit, DatasetRegistration, FeatureType, HoverConfig, LinearScale } from '@primeui/chart-types';
+import type { ComputedRef, Ref, ShallowRef } from 'vue';
+export type ChartCandlestickProps<T = unknown> = CandlestickProps<T>;
+export interface UseCandlestickRendererOptions {
+    chartArea: ComputedRef<BoxArea>;
+    renderer: 'svg' | 'canvas';
+    canvasEl: Ref<HTMLCanvasElement | null> | ShallowRef<HTMLCanvasElement | null>;
+    datasets: ComputedRef<Map<string, DatasetRegistration>>;
+    datasetVisibility: ComputedRef<Map<string, boolean>>;
+    features: ComputedRef<Map<FeatureType, {
+        type: FeatureType;
+        props: AnyFeatureProps;
+    }>>;
+    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>;
+    layoutData: ComputedRef<CartesianLayoutData | null>;
+    compositor?: CanvasCompositorLike;
+    /** Reactive theme — read via `.value` inside the composable. */
+    theme: ComputedRef<Required<ChartTheme>>;
+}
+export interface UseCandlestickRendererResult {
+    groupRef: Ref<SVGGElement | null>;
+    hitTest: (x: number, y: number) => CandlestickHitTestResult | null;
+    findAllNearest: (x: number, y: number) => {
+        primary: CartesianHitTestResult;
+        allSeries: CrosshairSeriesHit[];
+    } | null;
+    hasCandlestickData: ComputedRef<boolean>;
+    candlestickLayouts: Map<string, CandlestickRenderData>;
+    applyPropertyAnimations: (store: AnimatedPropertyStoreLike) => void;
+    renderFrameCycle: () => void;
+}

package/dist/types/canvas.types.d.ts

@@ -0,0 +1,5 @@
+import type { ChartSvgProps } from './svg.types';
+export interface ChartCanvasProps extends ChartSvgProps {
+    /** Override the device pixel ratio used for canvas rendering. Defaults to window.devicePixelRatio. Useful for exporting charts to bitmap or printing at higher DPI. */
+    devicePixelRatio?: number;
+}

package/dist/types/caption.types.d.ts

@@ -0,0 +1,8 @@
+import type { CaptionProps } from '@primeui/chart-types';
+export interface ChartCaptionProps extends CaptionProps {
+    fontWeight?: 'normal' | 'bold' | number;
+    padding?: number | {
+        top?: number;
+        bottom?: number;
+    };
+}

package/dist/types/cartesian.types.d.ts

@@ -0,0 +1,22 @@
+import type { ReferenceBandGeometry, ReferenceBandProps, ReferenceLineGeometry, ReferenceLineProps } from '@primeui/chart-types';
+import type { VNode } from 'vue';
+export interface ChartReferenceLineProps extends Omit<ReferenceLineProps, 'render'> {
+    id?: string;
+    render?: (context: ReferenceLineGeometry) => VNode | VNode[] | null;
+}
+export interface ChartReferenceBandProps extends Omit<ReferenceBandProps, 'render'> {
+    id?: string;
+    render?: (context: ReferenceBandGeometry) => VNode | VNode[] | null;
+}
+export interface CustomReferenceLineEntry {
+    key: string;
+    geo: ReferenceLineGeometry;
+    renderFn: (geo: ReferenceLineGeometry) => VNode | VNode[] | null;
+    placement: 'beforeData' | 'afterData';
+}
+export interface CustomReferenceBandEntry {
+    key: string;
+    geo: ReferenceBandGeometry;
+    renderFn: (geo: ReferenceBandGeometry) => VNode | VNode[] | null;
+    placement: 'beforeData' | 'afterData';
+}

package/dist/types/chart.types.d.ts

@@ -0,0 +1,51 @@
+import type { ChartTheme, DrilldownBreadcrumb, RendererType, ResolvedSyncConfig, SyncConfig } from '@primeui/chart-types';
+import type { SyncBus } from '@primeui/chart-core';
+import type { ComputedRef, MaybeRefOrGetter, Ref } from 'vue';
+export interface ChartProviderOptions {
+    chartId: string;
+    renderer: RendererType;
+    width: Ref<number>;
+    height: Ref<number>;
+    devicePixelRatio?: number;
+    dir?: Ref<'ltr' | 'rtl'>;
+    fontFamily?: string;
+    fontSize?: number;
+    locale?: Ref<string | undefined>;
+    /** Resolved chart theme (`resolveTheme(props.theme)`). Reactive — updates when entry component's `:theme` prop changes. */
+    theme: ComputedRef<Required<ChartTheme>>;
+}
+export interface DrilldownStateResult {
+    /** Current drill parent ID (null = root) */
+    currentParentId: Ref<string | null>;
+    /** Breadcrumb path */
+    path: Ref<DrilldownBreadcrumb[]>;
+    /** Whether drilldown is active (not at root) */
+    isActive: ComputedRef<boolean>;
+    /** Whether any dataset supports drilldown */
+    enabled: ComputedRef<boolean>;
+    /** Drill into a node. Optional ancestors array for intermediate parents not yet in the path. */
+    drillInto: (nodeId: string, label: string, ancestors?: DrilldownBreadcrumb[]) => void;
+    /** Navigate to a specific breadcrumb level */
+    drillToLevel: (index: number) => void;
+}
+export interface UseChartSyncOptions {
+    chartId: string;
+    /** Sync config — supports reactive getter so config changes after mount propagate via syncBus.updateConfig. */
+    sync?: MaybeRefOrGetter<SyncConfig | boolean | undefined>;
+}
+export interface ChartSyncInfo {
+    bus: SyncBus;
+    chartId: string;
+    config: ResolvedSyncConfig;
+}
+export interface UseChartSyncResult {
+    syncInfo: ChartSyncInfo | null;
+}
+export interface HoverExtras {
+    snapX?: number;
+    snapY?: number;
+    cursorX?: number;
+    cursorY?: number;
+    cursorFormattedValue?: string;
+    allSeriesHits?: import('@primeui/chart-core').CrosshairSeriesHit[];
+}

package/dist/types/heatmap.types.d.ts

@@ -0,0 +1,58 @@
+import type { AnimatedPropertyStoreLike, CanvasCompositorLike, AnyFeatureProps, AxisConfig, AxisLayoutInfo, BandScale, BoxArea, ChartTheme, ColorScaleInfo, DatasetRegistration, FeatureType, GlobalFont, HeatmapHitTestResult, HeatmapProps, HoverConfig } from '@primeui/chart-types';
+import type { ComputedRef, Ref, ShallowRef, VNode } from 'vue';
+export type ChartHeatmapProps<T = unknown> = HeatmapProps<T, VNode | null>;
+export interface UseHeatmapRendererOptions {
+    chartArea: ComputedRef<BoxArea>;
+    renderer: 'svg' | 'canvas';
+    canvasEl: Ref<HTMLCanvasElement | null> | ShallowRef<HTMLCanvasElement | null>;
+    datasets: ComputedRef<Map<string, DatasetRegistration>>;
+    axes: ComputedRef<{
+        x: Map<string, AxisConfig>;
+        y: Map<string, AxisConfig>;
+    }>;
+    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>;
+    features: ComputedRef<Map<FeatureType, {
+        type: FeatureType;
+        props: AnyFeatureProps;
+    }>>;
+    compositor?: CanvasCompositorLike;
+    globalFont?: GlobalFont;
+    /** Reactive locale ref — `.value` is read inside the renderer computed so locale changes trigger a repaint. */
+    locale?: Ref<string | undefined>;
+    /** Reactive theme — read via `.value` inside the composable. */
+    theme: ComputedRef<Required<ChartTheme>>;
+}
+export interface UseHeatmapRendererResult {
+    groupRef: Ref<SVGGElement | null>;
+    gridGroupRef: Ref<SVGGElement | null>;
+    axisGroupRef: Ref<SVGGElement | null>;
+    hitTest: (x: number, y: number) => HeatmapHitTestResult | null;
+    getPointPosition: (datasetId: string, index: number) => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        shape: 'rect';
+    } | null;
+    hasHeatmapData: ComputedRef<boolean>;
+    axisLayouts: ComputedRef<Map<string, AxisLayoutInfo>>;
+    plotArea: ComputedRef<BoxArea>;
+    getColorScaleInfo: () => ColorScaleInfo | null;
+    scaleResult: ComputedRef<{
+        xScale: BandScale;
+        yScale: BandScale;
+        xCategories: string[];
+        yCategories: string[];
+    } | null>;
+    svgContent: ComputedRef<VNode[]>;
+    applyPropertyAnimations: (store: AnimatedPropertyStoreLike) => void;
+    renderFrameCycle: () => void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,27 @@
+export type { UseCartesianAnimationOptions } from './animation.types';
+export type { ChartAxisGroupProps, ChartXAxisProps, ChartYAxisProps, SharedAxisProps } from './axes.types';
+export type { AxisCategoryCollector, ChartAxisCategoryProps } from './axisGroup.types';
+export type { ChartBarProps, UseBarRendererOptions, UseBarRendererResult } from './bar.types';
+export type { BreadcrumbProps } from './breadcrumb.types';
+export type { ChartCandlestickProps, UseCandlestickRendererOptions, UseCandlestickRendererResult } from './candlestick.types';
+export type { ChartCanvasProps } from './canvas.types';
+export type { ChartCaptionProps } from './caption.types';
+export type { ChartReferenceBandProps, ChartReferenceLineProps, CustomReferenceBandEntry, CustomReferenceLineEntry } from './cartesian.types';
+export type { ChartProviderOptions, ChartSyncInfo, DrilldownStateResult, HoverExtras, UseChartSyncOptions, UseChartSyncResult } from './chart.types';
+export type { ChartHeatmapProps, UseHeatmapRendererOptions, UseHeatmapRendererResult } from './heatmap.types';
+export type { ChartItemProps, UseDatasetRegistrationOptions, UseItemCollectorResult } from './item.types';
+export type { UseKeyboardNavigationOptions, UseKeyboardNavigationResult } from './keyboard.types';
+export type { UseCartesianLayoutOptions } from './layout.types';
+export type { ChartLegendProps, ColorLegendProps } from './legend.types';
+export type { ChartLineProps, LineAnimationConfig, UseLineRendererOptions, UseLineRendererResult } from './line.types';
+export type { ChartPieProps, UsePieRendererOptions, UsePieRendererResult } from './pie.types';
+export type { ChartPolarProps, UsePolarRendererOptions, UsePolarRendererResult } from './polar.types';
+export type { ChartRadarProps, UseRadarRendererOptions, UseRadarRendererResult } from './radar.types';
+export type { UseResponsiveDimensionsOptions, UseResponsiveDimensionsResult } from './responsiveDimensions.types';
+export type { ChartScatterProps, UseScatterRendererOptions, UseScatterRendererResult } from './scatter.types';
+export type { ChartPlugin, ChartPluginEntry, ChartSvgProps, RendererHint } from './svg.types';
+export type { ChartTooltipProps } from './tooltip.types';
+export type { ChartTreemapProps, TreemapGroupProps, UseTreemapRendererOptions, UseTreemapRendererResult } from './treemap.types';
+export type { UseZoomPanOptions, UseZoomPanResult } from './zoom.types';
+export type { AnimatedPropertyStoreLike, AnimationFeatureProps, AnyFeatureProps, AxisConfig, AxisGroupCollectorValue, AxisGroupRenderContext, AxisLayoutInfo, AxisTickMarkRenderContext, AxisTickRenderContext, BandScale, BaseAxisProps, BoxArea, BracketStyle, BreadcrumbItemContext, CandlestickHitTestResult, CanvasCompositorLike, CaptionProps, CartesianHitTestResult, CartesianLayoutData, ColorLegendRenderContext, ColorScaleInfo, ColorValue, CrosshairSeriesHit, CustomMarkerEntry, DatasetRegistration, DecimationAlgorithm, DrilldownBreadcrumb, FeatureType, FieldAccessor, FocusPosition, GradientColor, HeatmapHitTestResult, HoverConfig, HoverProps, ItemContext, ItemProps, KeyboardNavState, KeyboardNavigationConfig, LegendItemRenderContext, LegendProps, LineHitTestResult, LineRenderData, LineRenderProps, LinearScale, MarkerOverlayEntry, PartitionFillStyle, PartitionLabelStyle, PolarRenderData, PropertyAnimationConfig, RadarDatasetEntry, RadarRenderData, RadialHitTestResult, RangeFeatureProps, ReferenceBandGeometry, ReferenceLineGeometry, RendererType, ResolvedSyncConfig, ScatterHitTestResult, SeparatorStyle, SeriesType, SharedLegendItem, SyncConfig, TooltipProps, TooltipRenderContext, TreemapCellContext, ZoomProps, ZoomState } from '@primeui/chart-types';
+export type { AccessibilityProps, Alignment, AnimationConfig, AnnotationContext, AnnotationRender, AxisCategoryProps, AxisGroupDefinition, BarDatasetInfo, BarShapeFunction, BarShapeInfo, BarVisualLayoutOutput, BorderRadius, BracketThemeColors, CaptionOptions, CartesianFrameParams, ChartAreaAxes, ChartAreaDataset, ChartExportMethods, ChartHoverContextValue, ChartMethodsContextValue, ChartStateContextValue, ColorLegendRendererProps, CrosshairContext, CrosshairLayout, DataLabelAlignTo, DataLabelContext, DataLabelLineStyle, DecimationContextValue, DragState, DragType, EasingFunctionName, ExportMenuButtonOptions, ExportMenuIconContext, ExportMenuItem, ExportMenuItemContext, FeaturePropsMap, FrameContext, FullEffectConfig, GradientStop, HeatmapCellContext, HeatmapRenderProps, HitTestResult, HoverState, ItemCollectorContextValue, KeyNavAction, LastVisibleLayoutsCache, LegendItem, LegendOptions, LegendRendererProps, LinearGradientConfig, NavigatorProps, NavigatorRendererProps, NavigatorSeriesConfig, DataTableCellContext, PointDescriptionContext, PointPositionProvider, PointRenderContext, RadarSeriesProps, RadialGradient, RadialGridLayout, RadialXAxisConfig, RadialYAxisConfig, RangeContextValue, ReferenceBandFeatureProps, ReferenceLineFeatureProps, ResponsiveBreakpoints, ResponsiveConfigResult, ResponsiveFeatureProps, ResponsiveFeatureProps as ResponsiveProps, ResponsiveRule, RingLayoutInfo, ScaleFunction, SegmentContext, SeriesDescriptionContext, SharedLegendItemProps, SharedLegendMode, SliceRenderContext, SliceState, StackedContextValue, SyncBus, SyncDatasetInfo, TickStyle, TickValue, TitleOptions, TitleProps, TooltipItem, TooltipRow, TooltipState, UseAxisComponentBaseResult, XAxisProps, YAxisProps, ZoomAxisWindow, ZoomControllerConfig, ZoomHandle, ZoomMode } from '@primeui/chart-core';

package/dist/types/item.types.d.ts

@@ -0,0 +1,25 @@
+import type { ItemProps, SeriesType } from '@primeui/chart-types';
+import type { Ref } from 'vue';
+export interface ChartItemProps extends ItemProps {
+    borderRadius?: number | {
+        topLeft?: number;
+        topRight?: number;
+        bottomRight?: number;
+        bottomLeft?: number;
+    };
+    y?: number;
+}
+export interface UseDatasetRegistrationOptions<T> {
+    /** Unique identifier for this dataset */
+    id: Ref<string>;
+    /** Series type (bar, line, area, pie, etc.) */
+    type: SeriesType;
+    /** Component props — reactive */
+    props: Ref<T>;
+    /** Optional type resolver for dynamic types (e.g., pie vs donut based on innerRadius) */
+    typeResolver?: (props: T) => SeriesType;
+}
+export interface UseItemCollectorResult<T> {
+    /** Read collected items sorted by index. */
+    getItems: () => T[];
+}