@primeui/chart-core 0.0.1-alpha.1

package/dist/renderers/axis/index.d.mts

@@ -0,0 +1,39 @@
+import { AxisPosition, AxisSpaceOptions, AxisScale, BoxArea, XAxisProps, YAxisProps, AxisRenderData, SvgNode } from '@primeui/chart-types';
+import { ChartTheme } from '@primeui/chart-types/theme';
+
+/**
+ * Calculate required space for axis (for chart area calculation).
+ * Accepts either a string[] (backward-compatible) or AxisSpaceOptions.
+ */
+declare function calculateAxisSpace(position: AxisPosition, hasTitle: boolean, optionsOrLabels?: AxisSpaceOptions | string[], extraTitleOffset?: number, globalFont?: {
+    family?: string;
+    size?: number;
+}): number;
+
+/**
+ * Calculate axis layout from scale and props
+ */
+declare function calculateAxisLayout(scale: AxisScale, position: AxisPosition, chartArea: BoxArea, props: XAxisProps | YAxisProps, extraTitleOffset?: number, globalFont?: {
+    family?: string;
+    size?: number;
+}, locale?: string): AxisRenderData;
+
+declare function renderAxisSvg(layout: AxisRenderData, theme?: Required<ChartTheme>, options?: {
+    skipGrid?: boolean;
+    gridOnly?: boolean;
+    skipLabels?: boolean;
+    skipAxisLine?: boolean;
+    skipTicks?: boolean;
+    rtl?: boolean;
+}, axisIndex?: number): SvgNode;
+
+declare function renderAxisCanvas(ctx: CanvasRenderingContext2D, layout: AxisRenderData, options?: {
+    skipGrid?: boolean;
+    gridOnly?: boolean;
+    skipLabels?: boolean;
+    skipAxisLine?: boolean;
+    skipTicks?: boolean;
+    rtl?: boolean;
+}, theme?: Required<ChartTheme>, axisIndex?: number): void;
+
+export { calculateAxisLayout, calculateAxisSpace, renderAxisCanvas, renderAxisSvg };

package/dist/renderers/axis/index.mjs

@@ -0,0 +1,8 @@
+export { calculateAxisLayout, calculateAxisSpace, renderAxisCanvas, renderAxisSvg } from '../../chunk-ZTL2FQEW.mjs';
+import '../../chunk-R6Y3R7EW.mjs';
+import '../../chunk-XTVE4P3L.mjs';
+import '../../chunk-NKUYIWAP.mjs';
+import '../../chunk-QS76E3TD.mjs';
+import '../../chunk-O2X6FF45.mjs';
+import '../../chunk-SSLTFJ3U.mjs';
+import '../../chunk-RQ3CKQOX.mjs';

package/dist/renderers/circular/index.d.mts

@@ -0,0 +1,13 @@
+export { d as applyGradientBrightness, b as buildPieSvgChildren, r as renderCanvasCustomContent, a as renderCanvasDataLabels, e as restoreGradientBrightness, u as updatePieCustomContent, c as updateSvgSlices } from '../../canvas-D4vigq47.mjs';
+import { RadialSliceState, SliceRenderInfo, SliceGeometry, SliceRenderContext } from '@primeui/chart-types';
+
+/** Build a SliceRenderContext from animation state + render info */
+declare function buildSliceRenderContext(slice: RadialSliceState, renderInfo: SliceRenderInfo, position: {
+    x: number;
+    y: number;
+}, geo: SliceGeometry, chartCenter?: {
+    x: number;
+    y: number;
+}, fontFamily?: string): SliceRenderContext<unknown>;
+
+export { buildSliceRenderContext };

package/dist/renderers/circular/index.mjs

@@ -0,0 +1,13 @@
+export { applyGradientBrightness, buildPieSvgChildren, buildSliceRenderContext, renderCanvasCustomContent, renderCanvasDataLabels, restoreGradientBrightness, updatePieCustomContent, updateSvgSlices } from '../../chunk-B4FTADAZ.mjs';
+import '../../chunk-4C6EVJ54.mjs';
+import '../../chunk-LVMDQ4OJ.mjs';
+import '../../chunk-VGLSBZDN.mjs';
+import '../../chunk-BZN2QHGP.mjs';
+import '../../chunk-7CMVDIOU.mjs';
+import '../../chunk-OXTFAWSK.mjs';
+import '../../chunk-XTVE4P3L.mjs';
+import '../../chunk-NKUYIWAP.mjs';
+import '../../chunk-QS76E3TD.mjs';
+import '../../chunk-O2X6FF45.mjs';
+import '../../chunk-SSLTFJ3U.mjs';
+import '../../chunk-RQ3CKQOX.mjs';

package/dist/renderers/index.d.mts

@@ -0,0 +1,83 @@
+export { calculateAxisLayout, calculateAxisSpace, renderAxisCanvas, renderAxisSvg } from './axis/index.mjs';
+export { barRenderer, calculateBarLayout, computeBarDatasetTotals, computeBarLabelPosition, computeBarRenderStates, computeBarVisualLayout, hitTestBar } from '../series/bar/index.mjs';
+export { calculateCandlestickLayout, candlestickRenderer, findNearestCandleIndex, hitTestCandlestick } from '../series/candlestick/index.mjs';
+export { T as TooltipPosition, o as TooltipPositionInput, p as TooltipPositionStyle, b as buildRadialGridLayout, a as buildTooltipContent, q as calculateLabelMargins, c as calculateRadarLayout, d as computeRadialComboContext, e as computeTooltipPosition, s as extractCategories, t as getCategoryLabelAnchor, h as hitTestRadar, r as redrawRadialCanvas, f as renderCartesianFrame, g as renderCartesianOverlay, i as renderRadarSeriesCanvas, j as renderRadarSeriesSvg, k as renderRadialGridCanvas, l as renderRadialGridSvg, m as renderResolvedLabels, n as resolveSharedRadialGrid, u as resolveValues } from '../tooltip.renderer-D5wpSlBa.mjs';
+export { d as applyGradientBrightness, b as buildPieSvgChildren, r as renderCanvasCustomContent, a as renderCanvasDataLabels, e as restoreGradientBrightness, u as updatePieCustomContent, c as updateSvgSlices } from '../canvas-D4vigq47.mjs';
+export { buildSliceRenderContext } from './circular/index.mjs';
+export { calculateHeatmapLayout, heatmapRenderer, hitTestHeatmap } from '../series/heatmap/index.mjs';
+export { applyTipExtension, buildDualRangeFillPaths, buildFillPath, buildLinePath, buildRangeFillPath, buildStackedFillPath, calculateLineLayout, hitTestLine, lineRenderer, restoreTipExtension } from '../series/line/index.mjs';
+import { DrawMarkerCanvasOptions, SvgNode, CanvasOverlayParams } from '@primeui/chart-types';
+export { GRIP_LINE_GAP, HANDLE_WIDTH, MIN_SELECTION_WIDTH, NAV_DEFAULTS, NAV_PADDING_Y, buildNavigatorPaths, calculateNavigatorLayout, computeNavigatorJump, computeNavigatorJumpY, computeNavigatorPan, computeNavigatorPanY, computeNavigatorResizeBottom, computeNavigatorResizeLeft, computeNavigatorResizeRight, computeNavigatorResizeTop, computeNavigatorSelection, computeNavigatorTicks, createNavigatorScales, extractNavigatorData, hitTestNavigator, renderNavigatorCanvas, resolveNavigatorConfig } from './navigator/index.mjs';
+export { applyRingLayoutToProps, calculateMultiRingLayout, calculatePieLayout, computeSliceRenderStates, hitTestPie, pieRenderer } from '../series/pie/index.mjs';
+export { calculatePolarLayout, hitTestPolar } from '../series/polar/index.mjs';
+export { renderPolarBarsSvg } from '../series/polar/svg/index.mjs';
+export { renderPolarBarsCanvas } from '../series/polar/canvas/index.mjs';
+export { calculateScatterLayout, hitTestScatter, scatterRenderer } from '../series/scatter/index.mjs';
+export { calculateTreemapLayout, getCellLabelInfo, hitTestTreemap, treemapRenderer } from '../series/treemap/index.mjs';
+export { renderBarCanvas } from '../series/bar/canvas/index.mjs';
+export { renderBarSvg } from '../series/bar/svg/index.mjs';
+export { renderCanvasHeatmapContent } from '../series/heatmap/canvas/index.mjs';
+export { renderCanvasTreemapContent, renderTreemapCanvas } from '../series/treemap/canvas/index.mjs';
+export { renderHeatmapAxesSvg } from '../series/heatmap/svg/index.mjs';
+export { renderLineCanvas } from '../series/line/canvas/index.mjs';
+export { renderLineSvg } from '../series/line/svg/index.mjs';
+export { renderPieCanvas } from '../series/pie/canvas/index.mjs';
+export { renderPieSvg } from '../series/pie/svg/index.mjs';
+export { renderScatterCanvas } from '../series/scatter/canvas/index.mjs';
+export { renderScatterSvg } from '../series/scatter/svg/index.mjs';
+export { renderTreemapGroupHoverOverlay, renderTreemapSvg } from '../series/treemap/svg/index.mjs';
+import '@primeui/chart-types/theme';
+import '../series/candlestick/svg/index.mjs';
+import '../series/candlestick/canvas/index.mjs';
+import '../squarify.utils-B9CQBpa1.mjs';
+
+/**
+ * Runtime set of built-in marker shape names. Renderers check resolved
+ * `markerShape` strings against this set: a member → built-in shape; anything
+ * else is treated as a custom SVG path `d` string. Mirrors {@link PointStyle}.
+ */
+declare const MARKER_SHAPE_NAMES: ReadonlySet<string>;
+/**
+ * Equilateral triangle centered at (cx, cy) with the given half-size.
+ * Apex points up; centroid-centered.
+ */
+declare function buildEquilateralTrianglePath(cx: number, cy: number, size: number): string;
+/**
+ * Diamond (rotated square) centered at (cx, cy).
+ */
+declare function buildDiamondPath(cx: number, cy: number, size: number): string;
+/**
+ * Plus/cross shape centered at (cx, cy).
+ */
+declare function buildCrossPath(cx: number, cy: number, size: number): string;
+/**
+ * Five-pointed star centered at (cx, cy).
+ */
+declare function buildStarPath(cx: number, cy: number, size: number): string;
+/**
+ * Full marker paint on a canvas context: translate, set opacity/fill/stroke,
+ * trace the shape, then fill and stroke.
+ */
+declare function drawMarkerCanvas(ctx: CanvasRenderingContext2D, opts: DrawMarkerCanvasOptions): void;
+/**
+ * Create an SvgNode for a built-in marker shape centered at (cx, cy).
+ */
+declare function renderMarkerShapeSvg(shape: string, cx: number, cy: number, size: number, attrs: Record<string, string | number>): SvgNode;
+/**
+ * Trace a built-in marker shape path at origin (0, 0) on a canvas context.
+ * Caller is responsible for translate, fill, and stroke.
+ */
+declare function traceMarkerShapeCanvas(ctx: CanvasRenderingContext2D, shape: string, size: number): void;
+
+/**
+ * Generic canvas overlay renderer. Clears the overlay, optionally clips to a
+ * region, and calls the `draw` callback with an animate factory wired to the
+ * animation registry.
+ *
+ * Each renderer/component provides its own `draw` function that knows how to
+ * iterate its items and build render contexts — this function handles only the
+ * shared infrastructure.
+ */
+declare function renderCanvasOverlay(params: CanvasOverlayParams): void;
+
+export { MARKER_SHAPE_NAMES, buildCrossPath, buildDiamondPath, buildEquilateralTrianglePath, buildStarPath, drawMarkerCanvas, renderCanvasOverlay, renderMarkerShapeSvg, traceMarkerShapeCanvas };

package/dist/renderers/index.mjs

@@ -0,0 +1,75 @@
+export { buildTooltipContent, computeTooltipPosition, redrawRadialCanvas, renderRadialGridCanvas, renderRadialGridSvg } from '../chunk-DN6AXQYZ.mjs';
+export { renderNavigatorCanvas } from '../chunk-EAMUNLRU.mjs';
+export { GRIP_LINE_GAP, HANDLE_WIDTH, MIN_SELECTION_WIDTH, NAV_DEFAULTS, NAV_PADDING_Y, buildNavigatorPaths, calculateNavigatorLayout, computeNavigatorJump, computeNavigatorJumpY, computeNavigatorPan, computeNavigatorPanY, computeNavigatorResizeBottom, computeNavigatorResizeLeft, computeNavigatorResizeRight, computeNavigatorResizeTop, computeNavigatorSelection, computeNavigatorTicks, createNavigatorScales, extractNavigatorData, hitTestNavigator, resolveNavigatorConfig } from '../chunk-BKP26M4K.mjs';
+export { applyGradientBrightness, buildPieSvgChildren, buildSliceRenderContext, renderCanvasCustomContent, renderCanvasDataLabels, restoreGradientBrightness, updatePieCustomContent, updateSvgSlices } from '../chunk-B4FTADAZ.mjs';
+import '../chunk-4C6EVJ54.mjs';
+export { calculateCandlestickLayout, candlestickRenderer, findNearestCandleIndex, hitTestCandlestick } from '../chunk-3OZLP4I4.mjs';
+import '../chunk-CINXJIRR.mjs';
+import '../chunk-FHTC2YDB.mjs';
+import '../chunk-CHW4RKY3.mjs';
+export { heatmapRenderer } from '../chunk-WFVOQ2QZ.mjs';
+export { renderHeatmapAxesSvg } from '../chunk-MTGMXRNF.mjs';
+export { renderCanvasHeatmapContent } from '../chunk-TQ6S34QZ.mjs';
+export { calculateHeatmapLayout, hitTestHeatmap } from '../chunk-3Z62EUJN.mjs';
+export { lineRenderer } from '../chunk-J65DBT4R.mjs';
+export { renderLineSvg } from '../chunk-3FFJEX4A.mjs';
+export { renderLineCanvas } from '../chunk-KQIFO5I3.mjs';
+export { applyTipExtension, buildDualRangeFillPaths, buildFillPath, buildLinePath, buildRangeFillPath, buildStackedFillPath, calculateLineLayout, hitTestLine, restoreTipExtension } from '../chunk-6HSEJLSR.mjs';
+import '../chunk-HDFGCN2F.mjs';
+import '../chunk-ZQFK6CAE.mjs';
+export { renderPolarBarsSvg } from '../chunk-SXHVDJGF.mjs';
+export { calculateLabelMargins, calculatePolarLayout, calculateRadarLayout, computeRadialComboContext, extractCategories, getCategoryLabelAnchor, hitTestPolar, hitTestRadar, renderRadarSeriesCanvas, renderRadarSeriesSvg, resolveValues } from '../chunk-WCG35U6M.mjs';
+export { renderPolarBarsCanvas } from '../chunk-ERVQB2VZ.mjs';
+export { applyRingLayoutToProps, calculateMultiRingLayout, calculatePieLayout, hitTestPie, pieRenderer } from '../chunk-RBLZRT5K.mjs';
+export { renderPieCanvas } from '../chunk-VWF57TS3.mjs';
+export { renderPieSvg } from '../chunk-IXOWSEHO.mjs';
+export { computeSliceRenderStates } from '../chunk-53HW45JB.mjs';
+import '../chunk-LVMDQ4OJ.mjs';
+export { buildRadialGridLayout, resolveSharedRadialGrid } from '../chunk-TA4MVAEX.mjs';
+export { scatterRenderer } from '../chunk-2QRS4YQ5.mjs';
+export { renderScatterSvg } from '../chunk-6STOLMCA.mjs';
+export { renderScatterCanvas } from '../chunk-AHYIS6EB.mjs';
+export { renderCanvasOverlay, renderCartesianFrame, renderCartesianOverlay, renderResolvedLabels } from '../chunk-QQBXUDM4.mjs';
+export { barRenderer, computeBarDatasetTotals, computeBarVisualLayout } from '../chunk-7QQ6ETB4.mjs';
+export { renderBarCanvas } from '../chunk-X7T34OLW.mjs';
+export { renderBarSvg } from '../chunk-SALTGZFR.mjs';
+export { calculateBarLayout, computeBarLabelPosition, computeBarRenderStates, hitTestBar } from '../chunk-AUF4CHDP.mjs';
+export { calculateAxisLayout, calculateAxisSpace, renderAxisCanvas, renderAxisSvg } from '../chunk-ZTL2FQEW.mjs';
+import '../chunk-AP3UYWYT.mjs';
+export { calculateScatterLayout, hitTestScatter } from '../chunk-DTWTCFRG.mjs';
+export { MARKER_SHAPE_NAMES, buildCrossPath, buildDiamondPath, buildEquilateralTrianglePath, buildStarPath, drawMarkerCanvas, renderMarkerShapeSvg, traceMarkerShapeCanvas } from '../chunk-PRDVPOZX.mjs';
+import '../chunk-VGLSBZDN.mjs';
+export { getCellLabelInfo, hitTestTreemap, treemapRenderer } from '../chunk-XIHBK5D3.mjs';
+export { renderCanvasTreemapContent, renderTreemapCanvas } from '../chunk-55Y3WI6S.mjs';
+export { renderTreemapGroupHoverOverlay, renderTreemapSvg } from '../chunk-RO4N6YFS.mjs';
+export { calculateTreemapLayout } from '../chunk-VVI3OBPJ.mjs';
+import '../chunk-ZT2Z7ERM.mjs';
+import '../chunk-KP2TWD4Z.mjs';
+import '../chunk-3WEMHXZI.mjs';
+import '../chunk-KVDEROP6.mjs';
+import '../chunk-YBJ56XJS.mjs';
+import '../chunk-NPDZLYIF.mjs';
+import '../chunk-EDAKJLNA.mjs';
+import '../chunk-JWFBOPM6.mjs';
+import '../chunk-5JCI2DEB.mjs';
+import '../chunk-BZN2QHGP.mjs';
+import '../chunk-OGJ6IIBW.mjs';
+import '../chunk-ARRGOEFX.mjs';
+import '../chunk-22ST6YPP.mjs';
+import '../chunk-FFMT6OCO.mjs';
+import '../chunk-7CMVDIOU.mjs';
+import '../chunk-ADKLH73T.mjs';
+import '../chunk-OXTFAWSK.mjs';
+import '../chunk-R6Y3R7EW.mjs';
+import '../chunk-XTVE4P3L.mjs';
+import '../chunk-NKUYIWAP.mjs';
+import '../chunk-OWW3K55O.mjs';
+import '../chunk-WA3OVISZ.mjs';
+import '../chunk-C36VWQ7A.mjs';
+import '../chunk-BETFQBM2.mjs';
+import '../chunk-WRULPWHD.mjs';
+import '../chunk-QS76E3TD.mjs';
+import '../chunk-O2X6FF45.mjs';
+import '../chunk-IEGLX7VL.mjs';
+import '../chunk-SSLTFJ3U.mjs';
+import '../chunk-RQ3CKQOX.mjs';

package/dist/renderers/navigator/index.d.mts

@@ -0,0 +1,103 @@
+import { NavigatorPoint, NavigatorScales, NavigatorPaths, BoxArea, NavigatorProps, DatasetRegistration, ZoomState, ChartTheme, NavigatorLayout, LinearScale, NavigatorDragResult, NavigatorSelection, NavigatorTick, NavigatorData, Padding, NavigatorHitZone, ResolvedNavigatorConfig } from '@primeui/chart-types';
+
+declare const NAV_PADDING_Y = 4;
+declare const NAV_PADDING_X = 6;
+declare const MIN_SELECTION_WIDTH = 20;
+declare const HANDLE_WIDTH = 6;
+declare const GRIP_LINE_GAP = 3;
+declare const NAV_DEFAULTS: {
+    readonly height: 60;
+    readonly gap: 8;
+    readonly color: "#94a3b8";
+    readonly opacity: 0.3;
+    readonly selectionColor: "rgba(59,130,246,0.7)";
+    readonly selectionFill: "rgba(59,130,246,0.08)";
+    readonly maskColor: "rgba(0,0,0,0.12)";
+};
+declare function resolveNavigatorConfig(config: NavigatorProps, theme?: Required<ChartTheme>): ResolvedNavigatorConfig;
+/**
+ * Extract navigator-friendly [x, y] points from a registered dataset.
+ * For candlestick series, uses `close` as the Y value.
+ */
+declare function extractNavigatorData(datasets: Map<string, DatasetRegistration>, targetSeriesId?: string, isTimeAxis?: boolean): NavigatorData | null;
+declare function createNavigatorScales(data: NavigatorData, width: number, height: number, padding?: Padding): NavigatorScales;
+/**
+ * Generate SVG area + line paths for the navigator mini chart.
+ * For scatter: generates dot positions. For bar: generates mini bar rects.
+ */
+declare function buildNavigatorPaths(points: NavigatorPoint[], scales: NavigatorScales, height: number, sourceType?: string): NavigatorPaths;
+/**
+ * Generate time axis ticks for the navigator.
+ * Uses the same tick engine as the main chart's time axis, but with
+ * ~200px tick spacing (like Highcharts navigator default).
+ */
+declare function computeNavigatorTicks(xDomain: [number, number], xScale: LinearScale, width: number, locale?: string, categoryLabels?: string[], isNumericAxis?: boolean, tickFormat?: ((value: string | number, index?: number) => string) | string): NavigatorTick[];
+/**
+ * Compute the selection window pixel position from zoom state.
+ */
+declare function computeNavigatorSelection(zoomState: ZoomState, xScale: LinearScale | null, width: number, yScale?: LinearScale | null, height?: number): NavigatorSelection;
+/**
+ * Compute the complete navigator layout: area, data, scales, paths, selection.
+ * When `config.series` is an array, all listed series are rendered — the first
+ * drives the X domain, ticks and drag; remaining series are rendered as lines
+ * on a shared Y scale that spans all their Y domains.
+ */
+declare function calculateNavigatorLayout(chartArea: BoxArea, config: NavigatorProps, datasets: Map<string, DatasetRegistration>, zoomState: ZoomState, isTimeAxis?: boolean, tickFormat?: ((value: string | number, index?: number) => string) | string, locale?: string, theme?: Required<ChartTheme>, overrideXDomain?: [number, number]): NavigatorLayout;
+/**
+ * Compute new zoom min/max for a pan gesture.
+ */
+declare function computeNavigatorPan(startMin: number, startMax: number, deltaPixels: number, xScale: LinearScale, domainBounds: [number, number]): NavigatorDragResult;
+/**
+ * Compute new zoom min/max for a left-edge resize.
+ */
+declare function computeNavigatorResizeLeft(startMin: number, max: number, deltaPixels: number, xScale: LinearScale, domainBounds: [number, number]): NavigatorDragResult;
+/**
+ * Compute new zoom min/max for a right-edge resize.
+ */
+declare function computeNavigatorResizeRight(min: number, startMax: number, deltaPixels: number, xScale: LinearScale, domainBounds: [number, number]): NavigatorDragResult;
+/**
+ * Compute new zoom min/max when clicking on the background to jump.
+ */
+declare function computeNavigatorJump(clickPixelX: number, currentWidth: number | null, xScale: LinearScale, domainBounds: [number, number]): NavigatorDragResult;
+/**
+ * Compute new Y zoom min/max for a 2D pan gesture.
+ * Y scale is inverted: positive deltaPixels (drag down) = decrease data values.
+ */
+declare function computeNavigatorPanY(startMin: number, startMax: number, deltaPixels: number, yScale: LinearScale, domainBounds: [number, number]): NavigatorDragResult;
+/**
+ * Compute new Y zoom min/max for top-edge resize.
+ * Top edge in pixels = max data value (Y scale inverted).
+ */
+declare function computeNavigatorResizeTop(min: number, startMax: number, deltaPixels: number, yScale: LinearScale, domainBounds: [number, number]): NavigatorDragResult;
+/**
+ * Compute new Y zoom min/max for bottom-edge resize.
+ * Bottom edge in pixels = min data value (Y scale inverted).
+ */
+declare function computeNavigatorResizeBottom(startMin: number, max: number, deltaPixels: number, yScale: LinearScale, domainBounds: [number, number]): NavigatorDragResult;
+/**
+ * Compute new Y zoom min/max when clicking background in 2D mode to jump.
+ */
+declare function computeNavigatorJumpY(clickPixelY: number, currentHeight: number | null, yScale: LinearScale, domainBounds: [number, number]): NavigatorDragResult;
+/**
+ * Determine which interaction zone a local-space coordinate falls in.
+ *
+ * @param localX - X position relative to navigator left edge
+ * @param selection - Current selection layout
+ * @param localY - Y position (required for 2D mode)
+ * @returns The zone type, or null if not zoomed (no interactive zones)
+ */
+declare function hitTestNavigator(localX: number, selection: NavigatorSelection, localY?: number, handleWidth?: number): NavigatorHitZone | null;
+
+/**
+ * Render the navigator onto a canvas context.
+ *
+ * Draws: background, grid lines, area chart, time labels, selection UI.
+ * The context should already be translated so (0,0) is the top-left of the
+ * navigator area.
+ *
+ * @param ctx - Canvas 2D context (pre-translated to navigator origin)
+ * @param layout - Precomputed navigator layout from calculateNavigatorLayout
+ */
+declare function renderNavigatorCanvas(ctx: CanvasRenderingContext2D, layout: NavigatorLayout): void;
+
+export { GRIP_LINE_GAP, HANDLE_WIDTH, MIN_SELECTION_WIDTH, NAV_DEFAULTS, NAV_PADDING_X, NAV_PADDING_Y, buildNavigatorPaths, calculateNavigatorLayout, computeNavigatorJump, computeNavigatorJumpY, computeNavigatorPan, computeNavigatorPanY, computeNavigatorResizeBottom, computeNavigatorResizeLeft, computeNavigatorResizeRight, computeNavigatorResizeTop, computeNavigatorSelection, computeNavigatorTicks, createNavigatorScales, extractNavigatorData, hitTestNavigator, renderNavigatorCanvas, resolveNavigatorConfig };

package/dist/renderers/navigator/index.mjs

@@ -0,0 +1,8 @@
+export { renderNavigatorCanvas } from '../../chunk-EAMUNLRU.mjs';
+export { GRIP_LINE_GAP, HANDLE_WIDTH, MIN_SELECTION_WIDTH, NAV_DEFAULTS, NAV_PADDING_X, NAV_PADDING_Y, buildNavigatorPaths, calculateNavigatorLayout, computeNavigatorJump, computeNavigatorJumpY, computeNavigatorPan, computeNavigatorPanY, computeNavigatorResizeBottom, computeNavigatorResizeLeft, computeNavigatorResizeRight, computeNavigatorResizeTop, computeNavigatorSelection, computeNavigatorTicks, createNavigatorScales, extractNavigatorData, hitTestNavigator, resolveNavigatorConfig } from '../../chunk-BKP26M4K.mjs';
+import '../../chunk-NPDZLYIF.mjs';
+import '../../chunk-NKUYIWAP.mjs';
+import '../../chunk-QS76E3TD.mjs';
+import '../../chunk-O2X6FF45.mjs';
+import '../../chunk-SSLTFJ3U.mjs';
+import '../../chunk-RQ3CKQOX.mjs';

package/dist/resize.utils-D_2qm6rv.d.mts

@@ -0,0 +1,142 @@
+import { Padding, BoxArea, Position, LegendOptions, PartialPieOptions, TitleOptions, CaptionOptions, GlobalFont, TitleCaptionLayout, LegendDimensions, TitleDimensions, ResponsiveRule, ResponsiveTier, AdaptiveDefaults, ResponsiveBreakpoints, ResizeDebouncerOptions } from '@primeui/chart-types';
+
+/**
+ * Normalizes padding input to a full Padding object
+ * Accepts a number (applies to all sides) or partial Padding object
+ */
+declare function normalizePadding(padding?: Partial<Padding> | number): Padding;
+/**
+ * Calculates the space needed for the title
+ */
+declare function calculateTitleDimensions(title?: TitleOptions, globalFont?: GlobalFont): TitleDimensions;
+/**
+ * Calculates the title area box based on position and available width
+ */
+declare function calculateTitleArea(title: TitleOptions | undefined, containerWidth: number, containerHeight: number, padding: Padding, globalFont?: GlobalFont): BoxArea | null;
+/**
+ * Calculates stacked layout for title + caption.
+ * Caption stacks adjacent to the title by default.
+ * When `caption.position` is set and differs from the title position, the caption
+ * is placed independently on its own side and does not stack with the title.
+ * When `floating` is true, totalHeight is 0 so the chart area is not reduced.
+ */
+declare function calculateTitleLayout(title: TitleOptions | undefined, caption: CaptionOptions | undefined, containerWidth: number, containerHeight: number, padding: Padding, floating?: boolean, globalFont?: GlobalFont): TitleCaptionLayout;
+/**
+ * Calculates the space needed for the legend based on position
+ */
+declare function calculateLegendDimensions(legend?: LegendOptions): LegendDimensions;
+/**
+ * Calculates the legend area box based on position and remaining space
+ */
+declare function calculateLegendArea(legend: LegendOptions | undefined, containerWidth: number, containerHeight: number, padding: Padding, titleArea: BoxArea | null, titlePosition: 'top' | 'bottom' | undefined): BoxArea | null;
+/**
+ * Calculates the usable chart area after accounting for padding, title, and legend
+ */
+declare function calculateChartArea(containerWidth: number, containerHeight: number, padding: Padding, titleArea: BoxArea | null, legendArea: BoxArea | null, titlePosition: 'top' | 'bottom' | undefined, legendPosition: Position | undefined): BoxArea;
+/**
+ * Calculates the optimal radius for a pie/donut chart within the chart area
+ * Also returns the center point for the chart
+ * For partial pies (sweepAngle <= 270), the center is adjusted to visually center the arc
+ *
+ * @param chartArea - The available chart area
+ * @param radiusPercent - Optional radius as percentage (0-100). Defaults to 100.
+ * @param partialPieOptions - Optional rotation and sweepAngle for partial pie centering
+ */
+declare function calculateRadiusAndCenter(chartArea: BoxArea, radiusPercent?: number, partialPieOptions?: PartialPieOptions): {
+    center: {
+        x: number;
+        y: number;
+    };
+    radius: number;
+};
+
+/**
+ * Compute the responsive tier for a given chart width.
+ */
+declare function getResponsiveTier(chartWidth: number, breakpoints?: Partial<ResponsiveBreakpoints>): ResponsiveTier;
+/**
+ * Get adaptive default values for a given tier.
+ * 'lg' tier matches the current hardcoded defaults.
+ *
+ * When `globalFont` is provided with a `size`, all font-related values are
+ * scaled proportionally using the em-based formula: `tierPx / 12 * globalSize`.
+ */
+declare function getAdaptiveDefaults(tier: ResponsiveTier, globalFont?: {
+    size?: number;
+}): AdaptiveDefaults;
+/**
+ * Compute an adaptive tick count based on axis pixel length.
+ * Returns the user's explicit tickCount if provided.
+ * Heuristic: ~1 tick per 40px, clamped between 5 and 15.
+ */
+declare function getAdaptiveTickCount(axisLength: number, userTickCount?: number): number;
+/**
+ * Evaluate responsive rules against current chart dimensions.
+ * Returns a shallow-merged object of all matching rule props (last rule wins on conflict).
+ * Rules are evaluated in array order — all matching rules are applied.
+ */
+/**
+ * Process raw container dimensions: apply aspect ratio enforcement and max dimension clamping.
+ * Pure math — no DOM or framework dependency.
+ */
+declare function processDimensions(rawWidth: number, rawHeight: number, options?: {
+    aspectRatio?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+}): {
+    width: number;
+    height: number;
+};
+/**
+ * Apply responsive rule overrides to an axis map.
+ * - No overrides → returns original map unchanged.
+ * - `visible: false` → returns empty map (axis group hidden).
+ * - Other props → shallow-merges into every axis entry's props.
+ */
+declare function applyAxisOverrides<K, V extends {
+    props: object;
+}>(axes: Map<K, V>, overrides: Record<string, unknown> | undefined): Map<K, V>;
+declare function evaluateResponsiveRules(rules: ResponsiveRule[], chartWidth: number, chartHeight: number): Record<string, Record<string, unknown>>;
+
+/**
+ * Batches resize events using RAF or timer-based debouncing.
+ * Used by both React and Vue responsive dimension hooks.
+ *
+ * @example
+ * ```ts
+ * const debouncer = new ResizeDebouncer({ useRAF: true });
+ *
+ * // In ResizeObserver callback:
+ * debouncer.schedule(processed, (dims) => {
+ *     width = dims.width;
+ *     height = dims.height;
+ * });
+ *
+ * // On unmount:
+ * debouncer.cancel();
+ * ```
+ */
+declare class ResizeDebouncer {
+    private pending;
+    private rafId;
+    private timerId;
+    private delayMs;
+    constructor(options?: ResizeDebouncerOptions);
+    /**
+     * Schedule a dimension update. The callback fires after debounce settles.
+     * Subsequent calls before settlement replace the pending dimensions.
+     */
+    schedule(dims: {
+        width: number;
+        height: number;
+    }, apply: (dims: {
+        width: number;
+        height: number;
+    }) => void): void;
+    /** Cancel any pending debounce. Call on unmount. */
+    cancel(): void;
+    /** Update debounce options (e.g. when props change). */
+    updateOptions(options: ResizeDebouncerOptions): void;
+}
+
+export { ResizeDebouncer as R, applyAxisOverrides as a, calculateLegendArea as b, calculateChartArea as c, calculateLegendDimensions as d, calculateRadiusAndCenter as e, calculateTitleArea as f, calculateTitleDimensions as g, calculateTitleLayout as h, evaluateResponsiveRules as i, getAdaptiveDefaults as j, getAdaptiveTickCount as k, getResponsiveTier as l, normalizePadding as n, processDimensions as p };

package/dist/ring.utils-DXvrxMkU.d.mts

@@ -0,0 +1,138 @@
+import { RadialSliceState, SliceState, RadialFrameContext, HoverConfig, ChartTheme, LabelLayoutOptions, BoxArea, ChartAreaBounds, DataLabelConfig, FieldAccessor, LabelLayoutResult, LabelConfig, RingLayoutInfo, PieDatasetEntry, PieContentItem, AnimatableSlice, RingTarget, DashAccessor, SliceStyleData, DatasetRegistration } from '@primeui/chart-types';
+import { RingLayoutInfo as RingLayoutInfo$1 } from '@primeui/chart-types/layout';
+
+/**
+ * Renders all pie/donut slices to a canvas context for a single frame.
+ * Pure function — no React or DOM dependencies.
+ */
+declare function renderCanvasSlices(ctx: CanvasRenderingContext2D, frame: RadialFrameContext, hoverConfig: HoverConfig | undefined, theme: Required<ChartTheme>): void;
+/**
+ * Builds a map of SliceState arrays grouped by dataset index.
+ * Used for pie/donut hit testing.
+ * Pure function — no React or DOM dependencies.
+ */
+declare function buildHitTestStates(slices: RadialSliceState[]): Map<string, SliceState[]>;
+
+declare const DEFAULT_LABEL_LAYOUT_OPTIONS: LabelLayoutOptions;
+/**
+ * Computes the largest radius that still fits labels + leader lines within the bounds.
+ * Called during layout phase so the pie can shrink before being drawn.
+ */
+declare function computeLabelAwareRadius(labelConfigs: LabelConfig[], initialRadius: number, bounds: ChartAreaBounds, options?: Partial<LabelLayoutOptions>): number;
+/**
+ * Calculates optimal label layout for circular charts.
+ * Positions labels at the given radius and uses push-apart to resolve vertical overlaps.
+ */
+declare function calculateLabelLayout(labelConfigs: LabelConfig[], initialRadius: number, bounds: ChartAreaBounds, options?: Partial<LabelLayoutOptions>): LabelLayoutResult;
+/**
+ * Converts a BoxArea to ChartAreaBounds.
+ */
+declare function boxAreaToBounds(area: BoxArea): ChartAreaBounds;
+/** Per-dataset accessors a pie renderer supplies so the builder can resolve each slice's label text. */
+interface PieDataLabelDatasetProps {
+    label?: FieldAccessor<unknown, string>;
+    data?: unknown[];
+}
+interface PieDataLabelLayout {
+    /** Positioned labels + leader lines, shared by the canvas and SVG draw passes. */
+    labelLayout: LabelLayoutResult;
+    /** originalIndex -> LabelConfig, for the custom `render` lookup. */
+    configsByIndex: Map<number, LabelConfig>;
+    /** originalIndex -> slice (only slices that produced a label), for hover/leader-line effects. */
+    labelSlices: Map<number, RadialSliceState>;
+}
+/**
+ * Builds the pie/donut data-label layout once from a radial frame, so the canvas
+ * (`renderCanvasDataLabels`) and SVG (`PieRendererController._renderSvgDataLabels`) paths
+ * consume identical configs, bounds, and positions. Keeping this in one place is what makes
+ * canvas/SVG label parity structural rather than something each renderer re-derives (the
+ * earlier centerX / mid-angle / fallback-color drift bugs lived in the two duplicated copies).
+ *
+ * Returns `null` when no slice qualifies for a label.
+ */
+declare function buildPieDataLabelLayout(frame: RadialFrameContext, labelConfig: DataLabelConfig, viewport: {
+    width: number;
+    height: number;
+}, datasetPropsMap: Map<number, PieDataLabelDatasetProps>): PieDataLabelLayout | null;
+
+/**
+ * Build a per-item visibility map for a single pie dataset.
+ * An item is visible when both its dataset and the item itself are visible.
+ * Returns only `actualVisibility` — the `renderVisibility` map (always true)
+ * that previously accompanied it was unused.
+ */
+declare function buildPieVisibilityMap(data: unknown[], datasetId: string, isDatasetVisible: (id: string) => boolean, isItemVisible: (datasetId: string, index: number) => boolean): Map<number, boolean>;
+/**
+ * Resolve the effective chart area and inner radius for a dataset that may be
+ * part of a concentric ring stack.  When no ring layout applies the original
+ * chartArea and props.innerRadius are returned unchanged.
+ */
+declare function applyRingLayout(chartArea: BoxArea, ringLayout: RingLayoutInfo | undefined, props: {
+    startAngle?: number;
+    sweepAngle?: number;
+    innerRadius?: number;
+}): {
+    effectiveChartArea: BoxArea;
+    effectiveInnerRadius: number;
+};
+/**
+ * Compute per-slice outer radius ratios for variable-radius pie charts.
+ * The slice with the highest visible value gets ratio 1.0; others are
+ * proportionally smaller.  Returns null when sliceRadiusValue is not set.
+ */
+declare function computeSliceRadiusRatios(data: unknown[], sliceRadiusValue: FieldAccessor<unknown, number> | undefined, actualVisibility: Map<number, boolean>): number[] | null;
+/** Minimal prop shape required to build slice style data */
+interface PieStyleProps {
+    color?: unknown;
+    borderStrokeWidth?: unknown;
+    borderColor?: unknown;
+    borderRadius?: unknown;
+    borderDash?: DashAccessor<unknown>;
+    borderDashOffset?: number;
+    spacing?: number;
+    hoverColor?: unknown;
+    hoverBorderColor?: unknown;
+}
+/**
+ * Build the SliceStyleData entry for a single slice.
+ * Resolves per-item accessors for border properties and picks the slice color.
+ */
+declare function buildSliceStyleData(props: PieStyleProps, item: unknown, index: number, targetAngle: number, radiusRatio: number, theme?: Required<ChartTheme>, value?: number | null, category?: string, seriesIndex?: number, seriesId?: string): SliceStyleData;
+/**
+ * Build a RingTarget for the animation state manager.
+ * Picks ring radii from the stacked ring layout when available, otherwise
+ * falls back to the values computed from the layout phase.
+ */
+declare function buildRingTarget(chartArea: BoxArea, datasetIndex: number, slices: AnimatableSlice[], ringLayouts: RingLayoutInfo[], datasetId: string, props: {
+    startAngle?: number;
+    sweepAngle?: number;
+}, fallbackInnerRadius: number, fallbackOuterRadius: number): RingTarget;
+/**
+ * Compute per-slice position + render context for custom SVG content overlays.
+ *
+ * Frameworks iterate the returned array and wrap each item in a framework
+ * `<g transform="translate(contentX, contentY)">`, then call
+ * `item.renderFn(item.context)` for the inner content and pass `item.key`
+ * to `controller.registerCustomContent`.
+ *
+ */
+declare function buildPieSliceContentItems(entries: PieDatasetEntry[], lastRenderedSlices: RadialSliceState[], ringRadii: Map<string, {
+    inner: number;
+    outer: number;
+}>, animationLayout: {
+    center: {
+        x: number;
+        y: number;
+    };
+    outerRadius: number;
+    innerRadius: number;
+} | null, hiddenItems: Map<string, Set<number>>, fontFamily?: string, theme?: Required<ChartTheme>): PieContentItem[];
+
+/**
+ * Calculate ring layouts for stacked pie charts (concentric rings) based on visible datasets.
+ * A ring is considered visible only if the dataset is visible AND at least one item is visible.
+ * Uses stackId to identify stacked datasets and order to determine ring position.
+ */
+declare function calculateRingLayouts(datasets: Map<string, DatasetRegistration>, isDatasetVisible: (id: string) => boolean, isItemVisible: (datasetId: string, index: number) => boolean, baseInnerRadius?: number, gap?: number): RingLayoutInfo$1[];
+
+export { DEFAULT_LABEL_LAYOUT_OPTIONS as D, applyRingLayout as a, boxAreaToBounds as b, buildHitTestStates as c, buildPieDataLabelLayout as d, buildPieSliceContentItems as e, buildPieVisibilityMap as f, buildRingTarget as g, buildSliceStyleData as h, calculateLabelLayout as i, calculateRingLayouts as j, computeLabelAwareRadius as k, computeSliceRadiusRatios as l, renderCanvasSlices as r };