@primeui/chart-core 0.0.1-alpha.1

package/dist/series/treemap/controller/index.mjs

@@ -0,0 +1,20 @@
+export { TreemapRendererController } from '../../../chunk-NHRK5KU2.mjs';
+import '../../../chunk-AGU3NG6D.mjs';
+import '../../../chunk-VN7CKCSE.mjs';
+import '../../../chunk-XIHBK5D3.mjs';
+import '../../../chunk-55Y3WI6S.mjs';
+import '../../../chunk-RO4N6YFS.mjs';
+import '../../../chunk-VVI3OBPJ.mjs';
+import '../../../chunk-KP2TWD4Z.mjs';
+import '../../../chunk-3WEMHXZI.mjs';
+import '../../../chunk-EDAKJLNA.mjs';
+import '../../../chunk-OGJ6IIBW.mjs';
+import '../../../chunk-7CMVDIOU.mjs';
+import '../../../chunk-XTVE4P3L.mjs';
+import '../../../chunk-NKUYIWAP.mjs';
+import '../../../chunk-WA3OVISZ.mjs';
+import '../../../chunk-BETFQBM2.mjs';
+import '../../../chunk-QS76E3TD.mjs';
+import '../../../chunk-O2X6FF45.mjs';
+import '../../../chunk-SSLTFJ3U.mjs';
+import '../../../chunk-RQ3CKQOX.mjs';

package/dist/series/treemap/controller-canvas/index.d.mts

@@ -0,0 +1,7 @@
+import { TreemapRendererController } from '../controller/index.mjs';
+import '@primeui/chart-types';
+
+/** Construct a TreemapRendererController wired with the Canvas painters only. */
+declare const createTreemapRendererCanvas: () => TreemapRendererController;
+
+export { createTreemapRendererCanvas };

package/dist/series/treemap/controller-canvas/index.mjs

@@ -0,0 +1,25 @@
+import { TreemapRendererController } from '../../../chunk-NHRK5KU2.mjs';
+import '../../../chunk-AGU3NG6D.mjs';
+import '../../../chunk-VN7CKCSE.mjs';
+import '../../../chunk-XIHBK5D3.mjs';
+import { renderCanvasTreemapContent, renderTreemapCanvas } from '../../../chunk-55Y3WI6S.mjs';
+import '../../../chunk-RO4N6YFS.mjs';
+import '../../../chunk-VVI3OBPJ.mjs';
+import '../../../chunk-KP2TWD4Z.mjs';
+import '../../../chunk-3WEMHXZI.mjs';
+import '../../../chunk-EDAKJLNA.mjs';
+import '../../../chunk-OGJ6IIBW.mjs';
+import '../../../chunk-7CMVDIOU.mjs';
+import '../../../chunk-XTVE4P3L.mjs';
+import '../../../chunk-NKUYIWAP.mjs';
+import '../../../chunk-WA3OVISZ.mjs';
+import '../../../chunk-BETFQBM2.mjs';
+import '../../../chunk-QS76E3TD.mjs';
+import '../../../chunk-O2X6FF45.mjs';
+import '../../../chunk-SSLTFJ3U.mjs';
+import '../../../chunk-RQ3CKQOX.mjs';
+
+// src/series/treemap/controller-canvas/index.ts
+var createTreemapRendererCanvas = () => new TreemapRendererController({ renderCanvas: renderTreemapCanvas, renderCanvasContent: renderCanvasTreemapContent });
+
+export { createTreemapRendererCanvas };

package/dist/series/treemap/controller-svg/index.d.mts

@@ -0,0 +1,7 @@
+import { TreemapRendererController } from '../controller/index.mjs';
+import '@primeui/chart-types';
+
+/** Construct a TreemapRendererController wired with the SVG painter only. */
+declare const createTreemapRendererSvg: () => TreemapRendererController;
+
+export { createTreemapRendererSvg };

package/dist/series/treemap/controller-svg/index.mjs

@@ -0,0 +1,25 @@
+import { TreemapRendererController } from '../../../chunk-NHRK5KU2.mjs';
+import '../../../chunk-AGU3NG6D.mjs';
+import '../../../chunk-VN7CKCSE.mjs';
+import '../../../chunk-XIHBK5D3.mjs';
+import '../../../chunk-55Y3WI6S.mjs';
+import { renderTreemapSvg } from '../../../chunk-RO4N6YFS.mjs';
+import '../../../chunk-VVI3OBPJ.mjs';
+import '../../../chunk-KP2TWD4Z.mjs';
+import '../../../chunk-3WEMHXZI.mjs';
+import '../../../chunk-EDAKJLNA.mjs';
+import '../../../chunk-OGJ6IIBW.mjs';
+import '../../../chunk-7CMVDIOU.mjs';
+import '../../../chunk-XTVE4P3L.mjs';
+import '../../../chunk-NKUYIWAP.mjs';
+import '../../../chunk-WA3OVISZ.mjs';
+import '../../../chunk-BETFQBM2.mjs';
+import '../../../chunk-QS76E3TD.mjs';
+import '../../../chunk-O2X6FF45.mjs';
+import '../../../chunk-SSLTFJ3U.mjs';
+import '../../../chunk-RQ3CKQOX.mjs';
+
+// src/series/treemap/controller-svg/index.ts
+var createTreemapRendererSvg = () => new TreemapRendererController({ renderSvg: renderTreemapSvg });
+
+export { createTreemapRendererSvg };

package/dist/series/treemap/index.d.mts

@@ -0,0 +1,15 @@
+import { TreemapRenderProps, BoxArea, ChartTheme, TreemapRect, TreemapRenderData, TreemapCell, CellLabelInfo, DatasetRenderer } from '@primeui/chart-types';
+export { renderTreemapGroupHoverOverlay, renderTreemapSvg } from './svg/index.mjs';
+export { renderCanvasTreemapContent, renderTreemapCanvas, renderTreemapCanvasClipped, renderTreemapGroupHoverCanvas } from './canvas/index.mjs';
+import { R as RowMetadata } from '../../squarify.utils-B9CQBpa1.mjs';
+
+declare function calculateTreemapLayout(props: TreemapRenderProps, chartArea: BoxArea, theme?: Required<ChartTheme>, previousLayout?: (TreemapRect & RowMetadata)[] | null): Omit<TreemapRenderData, 'datasetIndex'>;
+
+declare function hitTestTreemap(_x: number, _y: number, _props: TreemapRenderProps, layout: TreemapRenderData): number | null;
+
+/** Compute label sizing/visibility for a cell (tier match). */
+declare function getCellLabelInfo(cell: TreemapCell, labelMinSize?: number): CellLabelInfo;
+
+declare const treemapRenderer: DatasetRenderer<TreemapRenderProps, TreemapRenderData>;
+
+export { calculateTreemapLayout, getCellLabelInfo, hitTestTreemap, treemapRenderer };

package/dist/series/treemap/index.mjs

@@ -0,0 +1,12 @@
+export { getCellLabelInfo, hitTestTreemap, treemapRenderer } from '../../chunk-XIHBK5D3.mjs';
+export { renderCanvasTreemapContent, renderTreemapCanvas, renderTreemapCanvasClipped, renderTreemapGroupHoverCanvas } from '../../chunk-55Y3WI6S.mjs';
+export { renderTreemapGroupHoverOverlay, renderTreemapSvg } from '../../chunk-RO4N6YFS.mjs';
+export { calculateTreemapLayout } from '../../chunk-VVI3OBPJ.mjs';
+import '../../chunk-7CMVDIOU.mjs';
+import '../../chunk-XTVE4P3L.mjs';
+import '../../chunk-NKUYIWAP.mjs';
+import '../../chunk-BETFQBM2.mjs';
+import '../../chunk-QS76E3TD.mjs';
+import '../../chunk-O2X6FF45.mjs';
+import '../../chunk-SSLTFJ3U.mjs';
+import '../../chunk-RQ3CKQOX.mjs';

package/dist/series/treemap/svg/index.d.mts

@@ -0,0 +1,15 @@
+import { TreemapRenderData, TreemapRenderProps, GlobalFont, BaseInteractionState, CoreEffectConfig, ChartTheme, SvgNode } from '@primeui/chart-types';
+
+/** Render a treemap to an SVG node tree. */
+declare function renderTreemapSvg(props: TreemapRenderProps, layout: TreemapRenderData, context?: {
+    font?: GlobalFont;
+    interaction?: BaseInteractionState;
+    effects?: CoreEffectConfig;
+    theme: Required<ChartTheme>;
+}): SvgNode;
+/** Render the treemap group hover overlay into an existing SVG group. */
+declare function renderTreemapGroupHoverOverlay(overlay: SVGGElement, layouts: Map<string, {
+    layout: TreemapRenderData;
+}>, groupNodeId: string | null): void;
+
+export { renderTreemapGroupHoverOverlay, renderTreemapSvg };

package/dist/series/treemap/svg/index.mjs

@@ -0,0 +1,9 @@
+export { renderTreemapGroupHoverOverlay, renderTreemapSvg } from '../../../chunk-RO4N6YFS.mjs';
+import '../../../chunk-VVI3OBPJ.mjs';
+import '../../../chunk-XTVE4P3L.mjs';
+import '../../../chunk-NKUYIWAP.mjs';
+import '../../../chunk-BETFQBM2.mjs';
+import '../../../chunk-QS76E3TD.mjs';
+import '../../../chunk-O2X6FF45.mjs';
+import '../../../chunk-SSLTFJ3U.mjs';
+import '../../../chunk-RQ3CKQOX.mjs';

package/dist/slices-DtewiwJx.d.mts

@@ -0,0 +1,72 @@
+import { ArcConfig, ArcPreprocessResult, ComputedSlice } from '@primeui/chart-types';
+
+declare const CLIP_PIXEL_MARGIN = 1;
+/** Threshold for detecting full circle (avoids floating point issues with 360) */
+declare const FULL_CIRCLE_THRESHOLD = 359.9;
+/** Half PI constant for corner arc calculations */
+declare const HALF_PI: number;
+/**
+ * Check if an angle span represents a full circle
+ */
+declare function isFullCircle(sweepAngle: number): boolean;
+/**
+ * Check if a slice spans the full sweep angle (single slice covering entire chart)
+ */
+declare function isFullSweepSlice(angleSpan: number, sweepAngle: number): boolean;
+/**
+ * Convert polar coordinates (radius, angle) to Cartesian (x, y).
+ * Angle is in radians.
+ */
+declare function rThetaToXY(r: number, theta: number, cx: number, cy: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Preprocess arc configuration to determine rendering type and prepare values.
+ * This consolidates the common logic used by both buildSvgArcPath and drawCanvasArc:
+ * - Full circle detection
+ * - Angle conversion to radians
+ * - Border radius parsing and clamping
+ *
+ * @param config - Arc configuration
+ * @param isFullCircleChart - Whether the chart is a full 360° circle
+ * @returns Preprocessing result with render type and computed values
+ */
+declare function preprocessArcConfig(config: ArcConfig, isFullCircleChart: boolean): ArcPreprocessResult;
+
+declare function computeSlices(data: number[], originalIndices: number[], rotation?: number, sweepAngle?: number): ComputedSlice[];
+/**
+ * Get the center angle for a single-slice full-sweep scenario.
+ * Used for positioning text in charts with only one visible slice.
+ *
+ * @param rotation - Starting rotation angle (default: -90)
+ * @param sweepAngle - Total sweep angle (default: 360)
+ * @returns The center angle of the sweep
+ */
+declare function getSweepCenterAngle(rotation?: number, sweepAngle?: number): number;
+/**
+ * Check if a point is inside a slice.
+ * Used for hover/click detection on circular charts.
+ * Uses squared distance comparison to avoid Math.sqrt for performance.
+ *
+ * @param x - Point X coordinate (relative to center)
+ * @param y - Point Y coordinate (relative to center)
+ * @param slice - The slice to test against
+ * @param outerRadius - Outer radius of the slice
+ * @param innerRadius - Inner radius of the slice (0 for pie)
+ * @returns True if point is inside the slice
+ */
+declare function isPointInSlice(x: number, y: number, slice: Pick<ComputedSlice, 'rotation' | 'endAngle'>, outerRadius: number, innerRadius?: number): boolean;
+/**
+ * Find which slice contains a point.
+ *
+ * @param x - Point X coordinate (relative to center)
+ * @param y - Point Y coordinate (relative to center)
+ * @param slices - Array of slices to test
+ * @param outerRadius - Outer radius
+ * @param innerRadius - Inner radius (0 for pie)
+ * @returns Index of the slice containing the point, or -1 if none
+ */
+declare function findSliceAtPoint(x: number, y: number, slices: Array<Pick<ComputedSlice, 'rotation' | 'endAngle'>>, outerRadius: number, innerRadius?: number): number;
+
+export { CLIP_PIXEL_MARGIN as C, FULL_CIRCLE_THRESHOLD as F, HALF_PI as H, isFullSweepSlice as a, isPointInSlice as b, computeSlices as c, findSliceAtPoint as f, getSweepCenterAngle as g, isFullCircle as i, preprocessArcConfig as p, rThetaToXY as r };

package/dist/spatialIndex.utils-B_GJkotZ.d.mts

@@ -0,0 +1,5 @@
+import { QuadPoint, QuadBounds, Quadtree } from '@primeui/chart-types';
+
+declare function buildQuadtree(points: readonly QuadPoint[], bounds: QuadBounds): Quadtree;
+
+export { buildQuadtree as b };

package/dist/squarify.utils-B9CQBpa1.d.mts

@@ -0,0 +1,50 @@
+import { SquarifyItem, TreemapRect } from '@primeui/chart-types';
+
+/**
+ * Per-cell metadata attached by `squarify` / `resquarify` so subsequent
+ * `resquarify` calls can detect and preserve row structure.
+ *
+ * `_row` is the 0-indexed row this cell was placed in (per the squarify result).
+ * It is additive — existing callers that don't read `_row` are unaffected.
+ */
+interface RowMetadata {
+    _row: number;
+}
+/**
+ * Squarify layout algorithm.
+ *
+ * Places items into a rectangle, optimizing for aspect ratios close to 1:1.
+ * Items are sorted by value (descending) internally.
+ *
+ * @param items - Items with value and original index
+ * @param x - Rectangle x
+ * @param y - Rectangle y
+ * @param w - Rectangle width
+ * @param h - Rectangle height
+ * @returns Array of positioned rectangles
+ */
+declare function squarify(items: SquarifyItem[], x: number, y: number, w: number, h: number): (TreemapRect & RowMetadata)[];
+/**
+ * Squarify variant that preserves row structure when called repeatedly with
+ * the same ordered set of items.
+ *
+ * Identity is determined by `SquarifyItem.index` — callers must pass a stable
+ * `index` value per logical item across renders. If the post-sort identity
+ * sequence matches the previous result, row partitioning is preserved and
+ * cells are resized within each row using the new values. Otherwise, falls
+ * back to a fresh `squarify` call.
+ *
+ * On first call (`previousRects` is null/empty), delegates to `squarify`,
+ * which now tags each output cell with `_row` metadata.
+ *
+ * Industry precedent: d3-hierarchy's `treemapResquarify`.
+ */
+declare function resquarify(items: SquarifyItem[], x: number, y: number, w: number, h: number, previousRects: (TreemapRect & RowMetadata)[] | null): (TreemapRect & RowMetadata)[];
+/** Slice layout — horizontal strips */
+declare function sliceLayout(items: SquarifyItem[], x: number, y: number, w: number, h: number): TreemapRect[];
+/** Dice layout — vertical strips */
+declare function diceLayout(items: SquarifyItem[], x: number, y: number, w: number, h: number): TreemapRect[];
+/** SliceDice layout — alternates between slice and dice per depth */
+declare function sliceDiceLayout(items: SquarifyItem[], x: number, y: number, w: number, h: number, depth?: number): TreemapRect[];
+
+export { type RowMetadata as R, sliceLayout as a, squarify as b, diceLayout as d, resquarify as r, sliceDiceLayout as s };

package/dist/stacking-CChuAcLN.d.mts

@@ -0,0 +1,319 @@
+import { StyledGroupBoundary, BandScale, BoxArea, BracketThemeColors, BracketGeometry, StyledRangeBoundary, SvgNode, ChartAreaAxes, ChartAreaDataset, FeatureType, AnyFeatureProps, GlobalFont, SeriesType, DatasetRenderer, CanvasCompositorLike, CanvasLayer, CrosshairLayoutInput, CrosshairLayout, CrosshairConfig, NormalizedCrosshairConfig, FrameContext, CartesianLayoutData, AxisTransitionHandle, FrameBuildInput, CartesianFrameParams, CartesianAnimationDriver, AnimationConfig, LinearScale, AxisLayoutInfo, AnimationRegistryLike, CustomMarkerEntry, BarHitContext, CartesianHitTestResult, CrosshairSeriesHit, LineHitContext, LineHitTestResult, ScatterHitContext, ScatterHitTestResult, CandlestickHitContext, CandlestickHitTestResult, ColorValue, DataLabelConfig, ResolvedLabel, CartesianLayoutInput, LastVisibleLayoutsCache, LineRenderProps, LineRenderData, ScatterRenderProps, ScatterRenderData, CartesianModeFlags, TransformResult } from '@primeui/chart-types';
+
+/**
+ * Compute bracket geometry for category (band) axis group boundaries.
+ * Handles multi-depth nested groups, both horizontal and vertical orientations.
+ */
+declare function computeCategoryBracketGeometry(boundaries: StyledGroupBoundary[], categoryScale: BandScale, cartesianArea: BoxArea, categoryAxisSpace: number, orientation: 'horizontal' | 'vertical', theme: BracketThemeColors): BracketGeometry;
+/**
+ * Compute bracket geometry for value (linear) axis range boundaries.
+ * Single-depth, supports both orientations.
+ */
+declare function computeRangeBracketGeometry(boundaries: StyledRangeBoundary[], valueDomain: [number, number], valueScaleRange: [number, number], cartesianArea: BoxArea, valueAxisSpace: number, hasAxisTitle: boolean, orientation: 'horizontal' | 'vertical', theme: BracketThemeColors): BracketGeometry;
+/** Render bracket geometry as an SVG group. Returns null if geometry is empty. */
+declare function renderBracketsSvg(geometry: BracketGeometry): SvgNode | null;
+/** Render bracket geometry onto a canvas context. */
+declare function renderBracketsCanvas(ctx: CanvasRenderingContext2D, geometry: BracketGeometry): void;
+
+/**
+ * Compute the inner cartesian plot area by subtracting axis margins,
+ * group-label space, and range-label space from the outer chart box.
+ *
+ * This is a **pure function** with no framework dependencies. Framework
+ * wrappers should memoize the result and recompute whenever `outerArea`,
+ * `axes`, `datasets`, or `features` change.
+ *
+ * @param outerArea  Full chart bounding box (from ChartRenderer)
+ * @param axes       Registered X/Y axis config maps
+ * @param datasets   Registered dataset map
+ * @param features   Registered feature map
+ */
+/**
+ * Derive the left/right axis gutter widths from a naturalArea relative to its chartArea.
+ * Used by ChartGroup sync to publish and compare axis widths across sibling charts.
+ */
+/**
+ * Returns true for feature types that affect cartesian layout (axis sizing and stacking mode).
+ * Used by framework renderers to build a filtered features map so calculateCartesianArea
+ * only re-runs when layout-relevant config changes, not on dataLabels/zoom/hover updates.
+ */
+declare function isLayoutCriticalFeature(type: FeatureType): boolean;
+declare function computeNaturalAxisWidths(naturalArea: BoxArea, chartArea: BoxArea): {
+    left: number;
+    right: number;
+};
+/**
+ * Returns true when at least one natural axis gutter is narrower than the group max,
+ * meaning this chart needs to re-run calculateCartesianArea with forced minPadding.
+ */
+declare function needsAxisPadding(naturalArea: BoxArea, chartArea: BoxArea, maxWidths: {
+    left: number;
+    right: number;
+}): boolean;
+declare function calculateCartesianArea(outerArea: BoxArea, axes: ChartAreaAxes, datasets: Map<string, ChartAreaDataset>, features: Map<FeatureType, {
+    type: FeatureType;
+    props: AnyFeatureProps;
+}>, globalFont?: GlobalFont, locale?: string, renderersByType?: ReadonlyMap<SeriesType, Pick<DatasetRenderer<unknown, unknown>, 'getAxisHints'>>, minPadding?: {
+    left?: number;
+    right?: number;
+}): BoxArea;
+
+/**
+ * Registers one canvas layer per dataset with the compositor.
+ *
+ * @param compositor - The shared CanvasCompositor
+ * @param prefix - Layer ID prefix (e.g., 'bar', 'line', 'scatter', 'candlestick')
+ * @param datasetIds - Iterable of dataset IDs to register
+ * @param getOrder - Returns the paint order for a dataset (typically dataset.order)
+ * @param createPaint - Factory that returns the paint callback for a dataset
+ */
+declare function registerDatasetLayers(compositor: CanvasCompositorLike, prefix: string, datasetIds: Iterable<string>, getOrder: (dsId: string) => number, createPaint: (dsId: string) => CanvasLayer['paint']): void;
+/**
+ * Triggers a composited repaint if in canvas mode with active layers.
+ * Replaces the 3-4 line boilerplate repeated across all renderer hooks.
+ *
+ * @returns true if a repaint was triggered, false otherwise
+ */
+declare function triggerCompositorRepaint(renderer: 'svg' | 'canvas', canvas: HTMLCanvasElement | null, compositor?: CanvasCompositorLike): boolean;
+
+/**
+ * Compute crosshair badge layout from pure inputs.
+ * Positions category badge, cursor-value badge, and bar-value label
+ * relative to the plot area and axis positions.
+ */
+declare function computeCrosshairLayout(input: CrosshairLayoutInput): CrosshairLayout;
+/**
+ * Normalize `true | CrosshairConfig` shorthand into a resolved config object.
+ * Returns null if crosshair is disabled or not applicable.
+ */
+declare function normalizeCrosshairConfig(crosshair: boolean | CrosshairConfig | undefined): NormalizedCrosshairConfig | null;
+
+/** Creates a fresh animation driver state bag. */
+declare function createAnimationDriver(): CartesianAnimationDriver;
+/**
+ * Builds a CartesianFrameParams object from already-transitioned axis layouts.
+ * Used for both animated and static render paths.
+ *
+ * Callers must apply axis transition BEFORE calling this function.
+ */
+declare function buildFrameParams(ctx: FrameContext, cached: CartesianLayoutData, input: FrameBuildInput): CartesianFrameParams;
+/**
+ * Builds static frame params: applies the axis transition's current state to the
+ * cached layout's axis layouts, and constructs CartesianFrameParams.
+ *
+ * PURE: reads current state via `apply()`; tick advancement is the caller's
+ * responsibility. The settle loop ticks once per iteration via its predicate
+ * (before each `onFrame`); the timed animation ticks once at the top of its
+ * own `onFrame`. Image-load and hover repaints call this outside the settle
+ * loop with no tick — correct because the scene is already settled.
+ */
+declare function buildStaticFrame(ctx: FrameContext, cached: CartesianLayoutData, axisTransition: AxisTransitionHandle): CartesianFrameParams;
+/**
+ * Builds animated frame params: applies the axis transition's current state to
+ * the given animated axis layouts, and constructs CartesianFrameParams.
+ *
+ * PURE: reads current state via `apply()`; tick advancement is the caller's
+ * responsibility (timed-animation `onFrame` ticks once at its top before
+ * building animated frames).
+ */
+declare function buildAnimatedFrame(ctx: FrameContext, cached: CartesianLayoutData, axisTransition: AxisTransitionHandle, animatedInput: FrameBuildInput): CartesianFrameParams;
+/**
+ * Picks the frame the hover/theme repaint should render — shared by the React and
+ * Vue animation hooks so both stay in lockstep.
+ *
+ * Reuses the geometry the animation last painted (`driver.lastFrame`), refreshing
+ * only the frame context (theme / DOM refs) so a theme toggle still recolors. The
+ * geometry stays put: the hover repaint must NOT recompute the settled target, or
+ * the chrome snaps to it and fights the in-flight slide (the tick-stagger bug).
+ * Hover itself is read live by the caller's `renderFrame`, never frozen into
+ * `lastFrame`. Falls back to a freshly built static frame before the first paint,
+ * when no `lastFrame` exists yet.
+ */
+declare function resolveHoverRepaintFrame(driver: CartesianAnimationDriver, ctx: FrameContext, buildStatic: () => CartesianFrameParams): CartesianFrameParams;
+/**
+ * Wraps a render function with compositor phase-split rendering (canvas mode)
+ * and overlay painting. Identical logic in both React and Vue animation hooks.
+ */
+declare function renderWithCompositor(frameParams: CartesianFrameParams, renderFrameFn: (params: CartesianFrameParams) => void, options: {
+    renderer: 'svg' | 'canvas';
+    canvas: HTMLCanvasElement | null;
+    compositor?: CanvasCompositorLike;
+    overlayCanvas?: HTMLCanvasElement | null;
+    registry?: AnimationRegistryLike | null;
+    hover?: {
+        datasetId: string | null;
+        index: number | null;
+    };
+    markerOverlays?: CustomMarkerEntry[];
+    onImageLoad?: () => void;
+}): void;
+/** Cancel both in-flight rafs (timed animation + settle) on the driver. */
+declare function cancelDriverRafs(driver: CartesianAnimationDriver): void;
+/**
+ * The main animation driver logic — handles fingerprinting, domain lerp,
+ * category sort lerp, phase detection, and orchestrator animate/settle.
+ *
+ * Called from both React useEffect and Vue watch when layoutData changes.
+ * All framework-specific state must be unwrapped before calling.
+ */
+declare function driveCartesianUpdate(layout: CartesianLayoutData, driver: CartesianAnimationDriver, axisTransition: AxisTransitionHandle, animConfig: AnimationConfig | undefined, renderFrame: (params: CartesianFrameParams) => void, buildStatic: () => CartesianFrameParams, buildAnimated: (valueScales: Map<string, LinearScale>, valueDomains: Map<string, [number, number]>, axisLayouts: Map<string, AxisLayoutInfo>, categoryScale?: BandScale, valueXScales?: Map<string, LinearScale>) => CartesianFrameParams, globalFont?: {
+    family?: string;
+    size?: number;
+}, locale?: string): void;
+
+declare function barHitTest(x: number, y: number, ctx: BarHitContext): CartesianHitTestResult | null;
+declare function barFindNearest(x: number, y: number, ctx: BarHitContext): CartesianHitTestResult | null;
+declare function barFindAllNearest(x: number, y: number, ctx: BarHitContext): {
+    primary: CartesianHitTestResult;
+    allSeries: CrosshairSeriesHit[];
+} | null;
+
+declare function lineHitTest(x: number, y: number, ctx: LineHitContext): LineHitTestResult | null;
+declare function lineFindAllNearest(x: number, y: number, ctx: LineHitContext): {
+    primary: CartesianHitTestResult;
+    allSeries: CrosshairSeriesHit[];
+} | null;
+
+declare function scatterHitTest(x: number, y: number, ctx: ScatterHitContext): ScatterHitTestResult | null;
+
+declare function candlestickHitTest(x: number, y: number, ctx: CandlestickHitContext): CandlestickHitTestResult | null;
+declare function candlestickFindAllNearest(x: number, y: number, ctx: CandlestickHitContext): {
+    primary: CartesianHitTestResult;
+    allSeries: CrosshairSeriesHit[];
+} | null;
+
+type AllNearestResult = {
+    primary: CartesianHitTestResult;
+    allSeries: CrosshairSeriesHit[];
+};
+declare function resolveNearestHit(hit1: CartesianHitTestResult, hit2: CartesianHitTestResult, x: number, y: number): CartesianHitTestResult;
+/**
+ * Merges multiple `findAllNearest` results from different renderer types (bar, line,
+ * candlestick). Selects the primary hit from whichever renderer is closest to (x, y)
+ * and concatenates all allSeries arrays for the crosshair badge list.
+ */
+declare function mergeAllNearestResults(results: (AllNearestResult | null)[], x: number, y: number): AllNearestResult | null;
+
+type ComputedBarLike = {
+    dataIndex: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    value: number;
+    isNegative: boolean;
+    category?: string;
+};
+type ComputedPointLike = {
+    dataIndex: number;
+    x: number;
+    y: number;
+    value: number | null;
+    category: string;
+};
+type ComputedScatterPointLike = {
+    dataIndex: number;
+    px: number;
+    py: number;
+    yValue: number;
+    radius: number;
+};
+declare const BASELINE_TO_CANVAS: Record<string, CanvasTextBaseline>;
+/**
+ * Resolve data labels for bar series.
+ * Produces positioned, formatted ResolvedLabel entries ready for rendering.
+ */
+declare function resolveBarLabels(bars: ComputedBarLike[], colors: (ColorValue | undefined)[], datasetTotal: number, orientation: 'vertical' | 'horizontal', config: DataLabelConfig, isPercentStacked: boolean, seriesName?: string, data?: unknown[]): ResolvedLabel[];
+/**
+ * Resolve data labels for scatter series.
+ * Produces positioned, formatted ResolvedLabel entries ready for rendering.
+ * Labels are placed above each point's top edge and hard-cut when the series is hidden.
+ */
+declare function resolveScatterLabels(points: ComputedScatterPointLike[], seriesColor: string, config: DataLabelConfig, seriesName?: string, data?: unknown[]): ResolvedLabel[];
+/**
+ * Resolve data labels for line/area point series.
+ * Produces positioned, formatted ResolvedLabel entries ready for rendering.
+ */
+declare function resolvePointLabels(points: ComputedPointLike[], seriesColor: string, datasetTotal: number, config: DataLabelConfig, seriesName?: string, data?: unknown[]): ResolvedLabel[];
+
+/**
+ * Compute the full cartesian layout from pure inputs.
+ *
+ * This is the framework-agnostic equivalent of the React `useCartesianLayout` hook.
+ * It contains ALL layout computation logic with no React dependencies.
+ *
+ * The layout pipeline:
+ * 1. Collect bar datasets, detect mode (via detectCartesianMode)
+ * 2. Extract categories/values, group if using AxisGroup
+ * 3. Transform values for stacking modes (via transformValues)
+ * 4. Compute waterfall bases (via computeWaterfallBases)
+ * 5. Compute value domain (via computeCartesianDomain)
+ * 6. Create shared scales
+ * 7. Compute stack bases (via computeStackBases)
+ * 8. Calculate axis layouts
+ * 9.
+ *  Calculate per-dataset bar layouts + animation targets
+ */
+declare function computeCartesianLayout(input: CartesianLayoutInput, lastVisibleLayouts: LastVisibleLayoutsCache): CartesianLayoutData | null;
+
+/**
+ * Collects CustomMarkerEntry[] from line render layouts.
+ * Only includes datasets that have a `renderMarker` callback.
+ *
+ * @param layouts - Current (possibly animated) line render data per dataset
+ * @param renderPropsMap - Render props per dataset (contains renderMarker, color, effects, etc.)
+ * @param snapshot - If true, snapshot visiblePoints to prevent mutation (React canvas mode)
+ */
+declare function collectLineMarkerOverlays<TProps extends LineRenderProps<unknown>>(layouts: Map<string, LineRenderData>, renderPropsMap: Map<string, TProps>, snapshot?: boolean): CustomMarkerEntry[];
+/**
+ * Collects CustomMarkerEntry[] from scatter render layouts.
+ * Only includes datasets that have a `renderMarker` callback.
+ * Filters to visible points and maps scatter coordinates to overlay format.
+ */
+declare function collectScatterMarkerOverlays<TProps extends ScatterRenderProps<unknown>>(layouts: Map<string, ScatterRenderData>, renderPropsMap: Map<string, TProps>): CustomMarkerEntry[];
+
+/**
+ * Detect the active cartesian chart mode from dataset descriptors and feature flags.
+ * Pure function — no framework dependencies.
+ */
+declare function detectCartesianMode(datasets: {
+    stackId?: string;
+}[], features: {
+    stacking?: {
+        mode?: string;
+    };
+    waterfall?: {
+        totalField?: string;
+    };
+    overlap?: {};
+}): CartesianModeFlags;
+/**
+ * Apply mode-specific value transforms:
+ * - Percent mode: normalize each value to a percentage of its category total
+ *
+ * Returns new arrays — does not mutate input.
+ */
+declare function transformValues(valuesPerDataset: number[][], categoryCount: number, mode: {
+    isPercentStacked: boolean;
+}): TransformResult;
+/**
+ * Compute waterfall cumulative bases (per-category starting values).
+ * Each category's base is the running total of all previous categories.
+ * "Total" categories reset the running total.
+ */
+declare function computeWaterfallBases(valuesPerDataset: number[][], categoryCount: number, data: unknown[], totalField?: string): number[];
+/**
+ * Compute stack base positions for all datasets across all categories.
+ * Handles: normal stacking (with automatic pos/neg split),
+ * waterfall, and stacked-waterfall (with negative-step reversal).
+ *
+ * Positive values stack upward from 0, negative values stack downward —
+ * matching Highcharts `stacking: 'normal'` behavior. Users provide negative
+ * data values directly for population-pyramid style charts.
+ */
+declare function computeStackBases(datasetIds: string[], valuesPerDataset: number[][], categoryCount: number, mode: {
+    isStacked: boolean;
+    isWaterfall: boolean;
+}, waterfallBases?: number[], signsPerDataset?: (-1 | 0 | 1)[][]): Map<string, number[]>;
+
+export { renderWithCompositor as A, resolveBarLabels as B, resolveHoverRepaintFrame as C, resolveNearestHit as D, resolvePointLabels as E, resolveScatterLabels as F, scatterHitTest as G, triggerCompositorRepaint as H, BASELINE_TO_CANVAS as I, buildFrameParams as J, computeRangeBracketGeometry as K, computeWaterfallBases as L, detectCartesianMode as M, renderBracketsSvg as N, transformValues as O, barFindNearest as a, barFindAllNearest as b, barHitTest as c, buildAnimatedFrame as d, buildStaticFrame as e, calculateCartesianArea as f, cancelDriverRafs as g, candlestickFindAllNearest as h, candlestickHitTest as i, collectLineMarkerOverlays as j, collectScatterMarkerOverlays as k, computeCartesianLayout as l, computeCategoryBracketGeometry as m, computeCrosshairLayout as n, computeNaturalAxisWidths as o, computeStackBases as p, createAnimationDriver as q, driveCartesianUpdate as r, isLayoutCriticalFeature as s, lineFindAllNearest as t, lineHitTest as u, mergeAllNearestResults as v, needsAxisPadding as w, normalizeCrosshairConfig as x, registerDatasetLayers as y, renderBracketsCanvas as z };

package/dist/streaming.utils-DH-g1gNP.d.mts

@@ -0,0 +1,49 @@
+import { LineUpdateKind } from '@primeui/chart-types';
+
+/** Streaming intent for a per-point data update.
+ *
+ * - `'append'`: exactly one new value at the end; existing values unchanged.
+ * - `'scroll'`: same length; values shifted by one position (rolling window).
+ * - `'update'`: general value change — every point may have moved.
+ * - `'replace'`: explicit user signal that this is a wholesale data swap;
+ *   treated identically to `'update'` by current animation channels but
+ *   reserved for future divergence (e.g. crossfade instead of point lerp).
+ * - `'none'`: no animation hint; renderer/controller picks default behavior.
+ */
+type StreamingHint = LineUpdateKind | 'replace' | 'none';
+/** Auto-detect the streaming update kind by comparing array shapes.
+ *
+ * Delegates to the existing `detectLineUpdateKind` heuristic which classifies
+ * append / scroll / update based on length and content comparison.
+ *
+ * Callers that want explicit control should bypass this and pass the user's
+ * `updateMode` prop directly to the consumer (see LineRendererController's
+ * `_buildSceneTargets` for the canonical wiring).
+ * Returns the narrower `LineUpdateKind` (not the full `StreamingHint` union) because
+ * auto-detection cannot produce `'replace'` or `'none'` — those values only come from
+ * the user's explicit `animation.updateMode` prop.
+ */
+declare function detectStreamingUpdateKind(prev: number[] | undefined, next: number[]): LineUpdateKind;
+/** Composite Line geometry — the custom-interpolated field on `LineState`.
+ *
+ * Carrying both `values` and `streamingHint` together lets the interpolator
+ * branch on intent without needing access to renderer/controller state. The
+ * controller is authoritative for `streamingHint` (it resolves the user's
+ * `updateMode` prop and runs auto-detection when `'auto'`).
+ */
+interface LineGeometry {
+    values: number[];
+    streamingHint: StreamingHint;
+}
+/** Custom interpolator for `LineState.geometry`.
+ *
+ * - `'append' | 'scroll'`: snap to target.values; the controller's tip-extension
+ *   render pass handles the visible "last segment extension" animation.
+ * - `'update' | 'replace' | 'none'`: element-wise lerp via `lerpValues`.
+ *
+ * Read by `AnimatedElement.tick()` through the `AnimatableRegistry.custom`
+ * dispatch (Step 0 foundation, priority custom > color > number).
+ */
+declare function streamingPointsInterpolator<V>(from: V, to: V, t: number): V;
+
+export { type LineGeometry as L, type StreamingHint as S, detectStreamingUpdateKind as d, streamingPointsInterpolator as s };