@primeui/chart-core 0.0.1-alpha.1

package/LICENSE

@@ -0,0 +1,23 @@
+# License
+
+MIT License
+
+Copyright (c) 2026 PrimeTek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# PrimeUI Chart Core

package/dist/animations/index.d.mts

@@ -0,0 +1,136 @@
+export { A as AXIS_SETTLED_THRESHOLD, a as AXIS_SMOOTHING, b as AnimatedElement, c as AnimatedScene, d as AnimationRegistry, e as AxisTransitionState, B as BAR_ANIMATABLE_PROPS, C as CanvasCompositor, F as FrameSchedulerAPI, L as LINE_ANIMATABLE_PROPS, f as animatableBarToComputedBar, g as buildCandlestickFingerprint, h as buildHeatmapFingerprint, i as buildLineFingerprint, j as computeDrillOutOrigin, k as computeZoomTransform, l as createPolarEntranceLayout, m as createRadarEntranceLayout, n as detectLineUpdateKind, o as easeInBounce, p as easeInOutBounce, q as easeInOutCubic, r as easeInOutQuart, s as easeOutBack, t as easeOutBounce, u as easeOutCubic, v as easeOutElastic, w as easeOutExpo, x as easeOutQuad, y as easeOutQuart, z as easeOutQuint, D as easings, E as getEasing, G as getEasingNames, H as hasEasing, I as interpolateCartesianAxisLayout, J as interpolatePolarLayout, K as interpolateRadialGrid, M as lerp, N as lerpColor, O as lerpValues, P as linear, Q as normalizeAnimationsMap, R as registerEasing, S as resolveAnimatedProps, T as setFrameScheduler, U as setupPropertyAnimations } from '../property-animations-D433wXzz.mjs';
+export { A as AnimationController, a as animate } from '../controller-BJE1AZ3q.mjs';
+import { DomainLerpState, AxisLayoutInfo, BoxArea, LinearScale, GlobalFont, AxisTransitionHandle, DomainLerpFrame, BandScale, CategoryLerpState } from '@primeui/chart-types';
+export { A as AnimatedPropertyStore } from '../property-store-NORUWFND.mjs';
+export { L as LineGeometry, S as StreamingHint, d as detectStreamingUpdateKind, s as streamingPointsInterpolator } from '../streaming.utils-DH-g1gNP.mjs';
+import '@primeui/chart-types/axes';
+import '@primeui/chart-types/layout';
+import '@primeui/chart-types/polar';
+import '@primeui/chart-types/radar';
+
+/**
+ * Initialize domain lerp state for a new animation pass.
+ *
+ * For each axis in targetDomains:
+ * - If an existing lerp state exists, use its current values as the start
+ * - Otherwise, start = target (first render, no animation needed)
+ *
+ * Stale axes (in existing state but not in targetDomains) are removed.
+ *
+ * @param existingLerp - Current lerp state (mutated in place)
+ * @param targetDomains - New target domains from layout computation
+ * @param options.expansionStart - When true, start domain = union(currentStart, target).
+ *   Expansion is applied instantly (start ≥ target bounds so any new-extreme data stays
+ *   inside the scale at progress=0); contraction still lerps smoothly. Prevents the
+ *   "zoom bulge" where a new extreme value maps beyond the plot edge while the scale
+ *   catches up. Applies uniformly to every cartesian chart type.
+ *
+ *   Heuristic exception (Task 4 — toggle-on asymmetry fix): when the target domain
+ *   strictly grows on BOTH ends (target.min < start.min AND target.max > start.max),
+ *   we treat this as a likely dataset-visibility toggle-on. In that case `expansionStart`
+ *   would collapse the animation entirely (union == target, so the axis snaps to its
+ *   final state at t=0). We drop the union for that axis so the lerp animates from the
+ *   OLD (smaller) domain outward to the new target. Single-end expansions (steady-state
+ *   data growth) keep `expansionStart` semantics — no regression for the streaming case.
+ */
+declare function initDomainLerp(existingLerp: Map<string, DomainLerpState>, targetDomains: Map<string, [number, number]>, options?: {
+    expansionStart?: boolean;
+}): void;
+/**
+ * For each value-axis lerp state, diff the START vs TARGET tick set and feed the
+ * result to `axisTransitionState.setTickTargets`. The categorization is also
+ * stored on the lerp state so `advanceDomainLerp` can:
+ *   - render exiting ticks (no longer in target layout) at their mapped position
+ *   - apply per-tick opacity to ticks + grid lines via `applyTicks`
+ *
+ * Implementation notes:
+ *   - The TARGET tick set is taken straight from `axisLayouts.get(...).layout.ticks`
+ *     — that layout is computed from the new (target) scale by the layout pass.
+ *   - The START tick set is recomputed by re-running `calculateAxisLayout` against
+ *     a linear scale built from each lerp's `minStart/maxStart`. This is the only
+ *     extra layout pass per animation init (paid once, not per frame).
+ *   - Hidden / logarithmic axes are skipped — they don't lerp inside
+ *     `advanceDomainLerp` either, so wiring fade for them would be dead code.
+ *   - Ticks without a numeric `rawValue` are skipped — only linear value-axis
+ *     ticks participate in this lerp. Category-axis fade is Task 6.
+ */
+declare function initDomainLerpTickFade(lerpStates: Map<string, DomainLerpState>, axisLayouts: Map<string, AxisLayoutInfo>, valueScaleRange: [number, number], cartesianArea: BoxArea, orientation: 'vertical' | 'horizontal', axisTransitionState: Pick<AxisTransitionHandle, 'setTickTargets' | 'setRotationTargets'>, globalFont?: GlobalFont, locale?: string): void;
+/**
+ * Advance domain lerp by one frame.
+ *
+ * For each axis:
+ * - Skips hidden axes (no ticks to animate)
+ * - Skips logarithmic axes (linear interpolation is wrong for log scale)
+ * - Interpolates min/max between start and target at given progress
+ * - Creates a new linear scale from the interpolated domain
+ * - Recalculates axis layout (tick positions) for the new domain
+ *
+ * @param lerpStates - Mutable lerp state map (minCurrent/maxCurrent are updated)
+ * @param progress - Animation progress [0..1]
+ * @param axisLayouts - Current axis layouts from layout computation
+ * @param valueScaleRange - Scale output range [min, max] in pixels
+ * @param cartesianArea - Chart area bounds
+ * @param orientation - Chart orientation ('vertical' | 'horizontal')
+ * @param baseValueScales - Base (non-animated) value scales to clone
+ * @param baseValueDomains - Base (non-animated) value domains to clone
+ */
+declare function advanceDomainLerp(lerpStates: Map<string, DomainLerpState>, progress: number, axisLayouts: Map<string, AxisLayoutInfo>, valueScaleRange: [number, number], cartesianArea: BoxArea, orientation: 'vertical' | 'horizontal', baseValueScales: Map<string, LinearScale>, baseValueDomains: Map<string, [number, number]>, globalFont?: GlobalFont, locale?: string, axisTransitionState?: Pick<AxisTransitionHandle, 'applyTicks' | 'applyRotations' | 'hasTickEntry'>): DomainLerpFrame;
+/**
+ * Snap all lerp states to their target values (no animation).
+ * Call this when animation is disabled or on the non-animated render path.
+ */
+declare function snapDomainLerp(lerpStates: Map<string, DomainLerpState>): void;
+/**
+ * Initialize or update the time-domain lerp state.
+ * Uses the current interpolated value as start so mid-animation updates chain smoothly.
+ *
+ * @param options.expansionStart - When true, start = union(current, target). Expansion
+ *   is applied instantly (wider bounds); contraction lerps smoothly. Prevents timestamps
+ *   at the new domain's edges from mapping past the category range at progress=0 (the
+ *   "right-edge overflow" bulge during streaming).
+ */
+declare function initTimeDomainLerp(existing: DomainLerpState | null, target: [number, number], options?: {
+    expansionStart?: boolean;
+}): DomainLerpState;
+/**
+ * Advance the time-domain lerp by one frame.
+ *
+ * Interpolates the time-axis min/max, rebuilds the time scale and band adapter,
+ * and recomputes the category-axis layout so ticks slide smoothly.
+ *
+ * @returns Animated categoryScale + updated axisLayouts with the new time-axis layout
+ */
+declare function advanceTimeDomainLerp(lerp: DomainLerpState, progress: number, axisLayouts: Map<string, AxisLayoutInfo>, cached: {
+    orientation: 'vertical' | 'horizontal';
+    cartesianArea: BoxArea;
+    timestamps: number[];
+}): {
+    categoryScale: BandScale;
+    axisLayouts: Map<string, AxisLayoutInfo>;
+};
+/**
+ * Snap time-domain lerp to target (no animation).
+ */
+declare function snapTimeDomainLerp(lerp: DomainLerpState): void;
+
+/**
+ * Snapshot the current category-axis tick positions so the next sort
+ * transition can animate from these positions to the new ones.
+ *
+ * Call this BEFORE updating layout data — pass the OLD axisLayouts.
+ */
+declare function initCategoryLerp(axisLayouts: Map<string, AxisLayoutInfo>, orientation: 'vertical' | 'horizontal'): CategoryLerpState;
+/**
+ * Produce interpolated axis layouts for the given animation progress (0→1).
+ *
+ * Ticks, tick marks, and grid lines all slide from their previous positions
+ * (in `prevPositions`) toward the current positions in `axisLayouts`.
+ */
+declare function advanceCategoryLerp(axisLayouts: Map<string, AxisLayoutInfo>, prevPositions: CategoryLerpState, progress: number, orientation: 'vertical' | 'horizontal'): Map<string, AxisLayoutInfo>;
+/**
+ * Instantly settle the category lerp (non-animated path or on complete).
+ * Clears the state so no further interpolation occurs.
+ */
+declare function snapCategoryLerp(state: CategoryLerpState): void;
+
+export { advanceCategoryLerp, advanceDomainLerp, advanceTimeDomainLerp, initCategoryLerp, initDomainLerp, initDomainLerpTickFade, initTimeDomainLerp, snapCategoryLerp, snapDomainLerp, snapTimeDomainLerp };

package/dist/animations/index.mjs

@@ -0,0 +1,18 @@
+export { AXIS_SETTLED_THRESHOLD, AXIS_SMOOTHING, AnimatedPropertyStore, AnimationRegistry, AxisTransitionState, CanvasCompositor, advanceCategoryLerp, advanceDomainLerp, advanceTimeDomainLerp, initCategoryLerp, initDomainLerp, initDomainLerpTickFade, initTimeDomainLerp, snapCategoryLerp, snapDomainLerp, snapTimeDomainLerp } from '../chunk-KNDZP446.mjs';
+export { animatableBarToComputedBar } from '../chunk-FRST55HY.mjs';
+export { buildCandlestickFingerprint } from '../chunk-JO7VACY2.mjs';
+export { buildHeatmapFingerprint } from '../chunk-SANZPAJ4.mjs';
+export { computeDrillOutOrigin, computeZoomTransform } from '../chunk-AGU3NG6D.mjs';
+import '../chunk-ZTL2FQEW.mjs';
+export { AnimatedElement, AnimatedScene, BAR_ANIMATABLE_PROPS, LINE_ANIMATABLE_PROPS, normalizeAnimationsMap, resolveAnimatedProps, setupPropertyAnimations } from '../chunk-VN7CKCSE.mjs';
+export { AnimationController, animate, easeInBounce, easeInOutBounce, easeInOutCubic, easeInOutQuart, easeOutBack, easeOutBounce, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easings, getEasing, getEasingNames, hasEasing, linear, registerEasing } from '../chunk-3WEMHXZI.mjs';
+export { setFrameScheduler } from '../chunk-EDAKJLNA.mjs';
+import '../chunk-R6Y3R7EW.mjs';
+import '../chunk-XTVE4P3L.mjs';
+import '../chunk-NKUYIWAP.mjs';
+export { buildLineFingerprint, detectLineUpdateKind, detectStreamingUpdateKind, streamingPointsInterpolator } from '../chunk-XQQCGFYB.mjs';
+export { createPolarEntranceLayout, createRadarEntranceLayout, interpolateCartesianAxisLayout, interpolatePolarLayout, interpolateRadialGrid, lerp, lerpColor, lerpValues } from '../chunk-WH3C3Y7P.mjs';
+import '../chunk-QS76E3TD.mjs';
+import '../chunk-O2X6FF45.mjs';
+import '../chunk-SSLTFJ3U.mjs';
+import '../chunk-RQ3CKQOX.mjs';

package/dist/annotation.utils-Bm0lOO1o.d.mts

@@ -0,0 +1,290 @@
+import { FieldAccessor, ItemContext, DashAccessor, ChartTheme, SvgNode, CustomMarkerEntry, MarkerRenderItem, BuildLegendItemsOptions, LegendItem, SyncDatasetInfo, SharedLegendMode, SharedLegendItem, LegendStyleConfig, BoxArea, LegendInteractionContext, LegendClickAction, LegendHoverTarget, ReferenceBandFeatureProps, AxisLayoutInfo, BandScale, ReferenceBandGeometry, ReferenceLineFeatureProps, ReferenceLineGeometry, FeatureType, FeatureConfig, RadialGridLayout, GlobalFont, AnnotationContextParams, AnnotationContext, AnnotationRender } from '@primeui/chart-types';
+
+/**
+ * Field Accessor Utilities
+ *
+ * Provides functions to resolve a FieldAccessor from data items.
+ * Supports: field names, nested paths, functions, static values, and arrays.
+ *
+ * Per-item callbacks receive an {@link ItemContext} object — see common.types.ts.
+ * Array semantics (cycle vs clip) are chosen at the call site via {@link ResolveOptions}.
+ */
+
+declare function isAccessorFunction<T, R>(accessor: FieldAccessor<T, R>): accessor is (ctx: ItemContext<T>) => R | undefined;
+declare function isAccessorArray<T, R>(accessor: FieldAccessor<T, R>): accessor is R[];
+declare function isAccessorString<T, R>(accessor: FieldAccessor<T, R>): accessor is string;
+/**
+ * Build a minimal {@link ItemContext} from a datum + index. For call sites that
+ * don't have full series context (combo-chart `seriesIndex`, resolved `value`,
+ * `category`, etc.) — pass `extras` to fill in what's available.
+ */
+declare function makeItemContext<T>(datum: T, index: number, extras?: Partial<Omit<ItemContext<T>, 'datum' | 'index'>>): ItemContext<T>;
+/**
+ * Resolve a nested path like "customer.address.city" from an object
+ */
+declare function resolveNestedPath<T extends object>(obj: T, path: string): unknown;
+/**
+ * Check if a string looks like a nested path (contains dots but isn't a color)
+ */
+declare function isNestedPath(str: string): boolean;
+/**
+ * Options for {@link resolveAccessor}.
+ */
+interface ResolveOptions<R> {
+    /**
+     * Array form behaviour:
+     * - `'cycle'` (default) — `arr[index % length]`, palette semantics
+     * - `'clip'` — return fallback when `index >= length`, highlight semantics
+     */
+    arrayMode?: 'cycle' | 'clip';
+    /** Returned when the accessor resolves to undefined (callback returned undefined, array out-of-range, etc). */
+    fallback?: R;
+}
+/**
+ * Resolve a value from a FieldAccessor. Single resolver for every per-item
+ * prop in the chart library — array semantics chosen at call site.
+ *
+ * - function → invoked with `ctx`; `undefined` return uses fallback
+ * - array    → cycle (default) or clip + fallback per `opts.arrayMode`
+ * - string   → field name / nested path on `ctx.datum`, else treated as static value
+ * - scalar   → returned as-is
+ */
+declare function resolveAccessor<T, R>(accessor: FieldAccessor<T, R> | undefined, ctx: ItemContext<T>, opts?: ResolveOptions<R>): R | undefined;
+/**
+ * Resolve accessor for all items in a data array. Builds a minimal ItemContext
+ * per item — callers needing richer context (seriesIndex, value) should iterate
+ * themselves and call {@link resolveAccessor} with a fully-populated ctx.
+ *
+ * Returns `(R | undefined)[]`: per-item resolution can produce `undefined` when
+ * a function accessor returns nothing, a keyof T points to a missing field, or
+ * the accessor argument itself is undefined. Callers must handle the `undefined`
+ * case explicitly (e.g., `Number(v) || 0`, `String(v ?? '')`, or
+ * `.filter((v): v is R => v != null)`).
+ */
+declare function batchResolveAccessor<T, R>(accessor: FieldAccessor<T, R> | undefined, data: T[]): (R | undefined)[];
+/**
+ * Assert that a resolved accessor value is defined. Use at the boundary of
+ * required-field paths (categoryField, valueField, xField, yField, etc.)
+ * where `undefined` indicates a programming error in the caller's data,
+ * not a legitimate gap. Throws with a precise locator on failure.
+ */
+declare function resolveRequired<R>(value: R | undefined, fieldName: string, rowIndex?: number): R;
+/**
+ * Batch-resolve a required accessor over a data array, asserting that every
+ * row produced a value. Returns a plain `R[]` (no undefined) — callers can
+ * consume directly without per-item guards. For optional accessors that may
+ * legitimately return undefined, use {@link batchResolveAccessor} instead.
+ */
+declare function batchResolveRequired<T, R>(accessor: FieldAccessor<T, R> | undefined, data: T[], fieldName: string): R[];
+/**
+ * Resolve a {@link DashAccessor} to a `number[]` dash pattern at a given item.
+ * Accepts scalar arrays, named pattern shortcuts, `keyof T`, and per-item
+ * callbacks. Named shortcuts are expanded to their numeric equivalents.
+ *
+ * Returns `undefined` when the accessor is missing or its callback returns
+ * undefined — callers can treat that as "no dash" (solid stroke).
+ */
+declare function resolveDash<T>(accessor: DashAccessor<T> | undefined, ctx: ItemContext<T>): number[] | undefined;
+
+/**
+ * Resolve a default series color by index. Picks from `theme.series` looped via
+ * modulo. When a caller doesn't have a resolved theme in scope, omitting the
+ * argument falls back to `defaultLightTheme` — same hexes the wrapper would
+ * have produced via `resolveTheme(undefined)`.
+ */
+declare function getDefaultColor(index: number, theme?: Required<ChartTheme>): string;
+/**
+ * Resolve color with default fallback
+ */
+declare function resolveColor<T>(accessor: FieldAccessor<T, string> | undefined, ctx: ItemContext<T>, theme?: Required<ChartTheme>): string;
+
+/**
+ * Sibling-key uniqueness contract
+ * --------------------------------
+ * Callers MUST ensure no two *sibling* descriptors resolve to the same key (see
+ * `keyOf`/`keyOfNode` below) unless their tags can never differ. When two same-key
+ * siblings exist and one flips tag between renders (e.g. `rect` <-> `path`), the
+ * FIFO tag-guard in `reconcileSvgChildren` can cross-match them — patching one
+ * element's attributes onto the other's live node.
+ *
+ * Renderers satisfy this three different ways, chosen by feature need (so the
+ * border-emission strategy is deliberately NOT uniform across renderers):
+ *   1. a separate `data-layer` GROUP for the secondary shape — line/radar borders;
+ *   2. the secondary style applied to the SAME element as a stroke — scatter,
+ *      polar, heatmap, pie, candlestick (one keyed element per item, so a tag flip
+ *      is the safe single-element replace case);
+ *   3. a distinct key when a true sibling is unavoidable — the bar fill keeps
+ *      `data-index` while its border element keys by `id`, because `borderSkipped`
+ *      and `borderAlign: 'inner'` require a separate partial/clipped path that a
+ *      single stroked rect cannot express.
+ */
+/** Stable identity of a live element among its siblings, or null (→ tag-positional). */
+declare function keyOf(el: Element): string | null;
+/** Same identity, computed from a descriptor's attributes. */
+declare function keyOfNode(node: SvgNode): string | null;
+/** Reconcile a single matched (live, descriptor) pair in place. Caller guarantees same tag. */
+declare function reconcileSvgElement(live: Element, next: SvgNode): void;
+declare function reconcileSvgChildren(parent: Element, nextChildren: (SvgNode | string)[]): void;
+
+/**
+ * Render custom markers on a canvas context.
+ * Framework-agnostic — used by both React and Vue.
+ *
+ * Each entry represents a dataset with a `renderMarker` callback.
+ * The callback receives a `PointRenderContext` with `ctx` set to the canvas context,
+ * pre-translated to the point position.
+ */
+declare function renderCustomMarkersCanvas(ctx: CanvasRenderingContext2D, entries: CustomMarkerEntry[], hover: {
+    datasetId: string | null;
+    index: number | null;
+}, options?: {
+    createAnimate?: (dsId: string, pointIndex: number) => unknown;
+    onImageLoad?: () => void;
+}): void;
+/**
+ * Build marker render items from entries and hover state.
+ * Returns pure data — no DOM access. Framework adapters render these natively
+ * (React via JSX, Vue via h()/template).
+ */
+declare function buildMarkerRenderItems(entries: CustomMarkerEntry[], hover: {
+    datasetId: string | null;
+    index: number | null;
+}): MarkerRenderItem[];
+
+/**
+ * Resolve the effective text direction by walking up from `target` to the
+ * nearest ancestor with a `dir` attribute. Returns `'ltr'` when no ancestor
+ * has `dir="rtl"` or when `target` is null.
+ *
+ * Pure DOM read — safe to call repeatedly. Caller invokes this whenever it
+ * wants a fresh value (e.g. after `observeDocumentDir` fires).
+ */
+declare function resolveDirFromElement(target: Element | null | undefined): 'ltr' | 'rtl';
+/**
+ * Watch `<html dir>` mutations and run `onChange` whenever the attribute is
+ * updated. Returns a stop function that disconnects the observer.
+ *
+ * SSR-safe: when `document` or `MutationObserver` are unavailable, returns a
+ * no-op stop function and never observes anything.
+ *
+ * Does NOT call `onChange` synchronously — callers should resolve the initial
+ * value themselves before calling this.
+ */
+declare function observeDocumentDir(onChange: () => void): () => void;
+
+/**
+ * Build legend items from dataset registrations.
+ * Pure function — no framework dependency.
+ *
+ * Cartesian/Radar/Polar charts get one legend item per dataset.
+ * Radial charts (pie/donut) get one legend item per data point.
+ */
+declare function buildLegendItems(options: BuildLegendItemsOptions): LegendItem[];
+/**
+ * Build deduplicated rows for a multi-chart shared legend.
+ *
+ * Dedup strategy is **by label** (not by datasetId) — synced charts that share
+ * a series name (e.g. KPI sparklines + a detail chart, all rendering "Revenue")
+ * collapse into a single legend entry. Items inherit the first matching entry's
+ * color and order.
+ *
+ * Final order follows each label's first-seen `order` value across the
+ * flattened entry list.
+ */
+declare function buildSharedLegendItems(entries: SyncDatasetInfo[], mode: SharedLegendMode, visibilityMap: Map<string, boolean>): SharedLegendItem[];
+/**
+ * Compute CSS position/layout styles for the legend container.
+ * Returns a plain object compatible with any framework's style binding.
+ */
+declare function computeLegendStyle(config: LegendStyleConfig, legendArea: BoxArea): Record<string, string | number>;
+/**
+ * Pure reducer for legend item clicks.
+ *
+ * The user-supplied `onClick` callback short-circuits this — wrappers should
+ * invoke the callback first and only fall through to this reducer when no
+ * callback is set.
+ *
+ * Behavior:
+ * - Cartesian / rect / radar / polar: toggle entire dataset visibility.
+ * - Radial (pie/donut) `dataset` item: collapse-or-expand all data points (if
+ *   any are visible, hide them all; otherwise show them all).
+ * - Radial `item`: toggle that single data point.
+ */
+declare function resolveLegendClickAction(item: LegendItem, ctx: LegendInteractionContext): LegendClickAction;
+/**
+ * Resolve a legend hover event to the target the wrapper should pass to
+ * `setHover(datasetId, index)`. `null` means clear hover entirely.
+ *
+ * - Cartesian/radar/polar dataset hover sets `index: null` to highlight the whole
+ *   series (and dim the rest) — consistent across all per-series legends.
+ * - Radial item hover (pie/donut) sets the specific point.
+ * - Any other dataset legend (e.g. stacked-pie headers) and null/empty input clear hover.
+ */
+declare function resolveLegendHoverTarget(item: LegendItem | null, ctx: {
+    isCartesian: boolean;
+    hasRadarDatasets: boolean;
+    hasPolarDatasets: boolean;
+}): LegendHoverTarget | null;
+
+declare class ItemCollector<T extends object> {
+    private readonly items;
+    private counter;
+    registerItem(index: number, props: T): void;
+    unregisterItem(index: number): void;
+    getNextIndex(): number;
+    getItems(): T[];
+}
+
+/**
+ * Compute plot line geometries from feature props.
+ */
+declare function computeReferenceLines(referenceLines: ReferenceLineFeatureProps[], axisLayouts: Map<string, AxisLayoutInfo>, cartesianArea: BoxArea, categoryScale: BandScale | null, orientation: 'horizontal' | 'vertical'): ReferenceLineGeometry[];
+/**
+ * Compute plot band geometries from feature props.
+ */
+declare function computeReferenceBands(referenceBands: ReferenceBandFeatureProps[], axisLayouts: Map<string, AxisLayoutInfo>, cartesianArea: BoxArea, categoryScale: BandScale | null, orientation: 'horizontal' | 'vertical'): ReferenceBandGeometry[];
+
+declare function renderReferenceBandsCanvas(ctx: CanvasRenderingContext2D, bands: ReferenceBandGeometry[], globalFont: GlobalFont | undefined, theme: Required<ChartTheme>): void;
+declare function renderReferenceLinesCanvas(ctx: CanvasRenderingContext2D, lines: ReferenceLineGeometry[], globalFont: GlobalFont | undefined, theme: Required<ChartTheme>): void;
+/**
+ * Collect reference-line and reference-band feature props from a chart's feature map.
+ * Features are keyed `referenceLine:<id>` / `referenceBand:<id>` at registration.
+ */
+declare function extractReferenceFeatures(features: ReadonlyMap<FeatureType, FeatureConfig>): {
+    referenceLines: ReferenceLineFeatureProps[];
+    referenceBands: ReferenceBandFeatureProps[];
+};
+/** Merge extracted reference features into a radial grid layout (undefined when empty). */
+declare function withReferenceFeatures(layout: RadialGridLayout, features: ReadonlyMap<FeatureType, FeatureConfig>): RadialGridLayout;
+
+/**
+ * Shared style constants for chart overlay components (legend, tooltip).
+ * Framework adapters import these instead of duplicating the values.
+ */
+/** Base styles for legend items (static properties only) */
+declare const LEGEND_ITEM_BASE_STYLE: Record<string, string | number>;
+/** Styles for legend color swatch */
+declare const LEGEND_SWATCH_STYLE: Record<string, string | number>;
+/** Base styles for tooltip positioning (static properties only) */
+declare const TOOLTIP_BASE_STYLE: Record<string, string | number>;
+/**
+ * Default tooltip layout (stacks content vertically). Visual chrome
+ * (background, blur, border, radius, padding, shadow, color) lives in the
+ * `.p-chart-tooltip` CSS rule so it's overridable via CSS or the theme tokens.
+ */
+declare const TOOLTIP_DEFAULT_STYLE: Record<string, string | number>;
+/** Tooltip color indicator styles (retained for backward-compat; default renderers use the `.p-chart-tooltip__swatch` class). */
+declare const TOOLTIP_COLOR_INDICATOR_STYLE: Record<string, string | number>;
+
+/**
+ * Build an AnnotationContext from ChartRenderer-level inputs.
+ * Returns a context without `ctx` — the caller adds it for canvas mode.
+ */
+declare function buildAnnotationContext(params: AnnotationContextParams): Omit<AnnotationContext, 'ctx'>;
+/**
+ * Render all annotations to a canvas context.
+ * Each annotation is wrapped in save/restore with textColor as default fillStyle.
+ */
+declare function renderAnnotationsCanvas(ctx: CanvasRenderingContext2D, annotations: Map<string, AnnotationRender>, baseContext: Omit<AnnotationContext, 'ctx'>): void;
+
+export { resolveRequired as A, withReferenceFeatures as B, getDefaultColor as C, isAccessorArray as D, isAccessorFunction as E, isAccessorString as F, isNestedPath as G, renderReferenceBandsCanvas as H, ItemCollector as I, renderReferenceLinesCanvas as J, resolveColor as K, LEGEND_ITEM_BASE_STYLE as L, resolveNestedPath as M, TOOLTIP_BASE_STYLE as T, LEGEND_SWATCH_STYLE as a, TOOLTIP_COLOR_INDICATOR_STYLE as b, TOOLTIP_DEFAULT_STYLE as c, batchResolveAccessor as d, batchResolveRequired as e, buildAnnotationContext as f, buildLegendItems as g, buildMarkerRenderItems as h, buildSharedLegendItems as i, computeLegendStyle as j, computeReferenceBands as k, computeReferenceLines as l, extractReferenceFeatures as m, keyOf as n, keyOfNode as o, makeItemContext as p, observeDocumentDir as q, reconcileSvgChildren as r, reconcileSvgElement as s, renderAnnotationsCanvas as t, renderCustomMarkersCanvas as u, resolveAccessor as v, resolveDash as w, resolveDirFromElement as x, resolveLegendClickAction as y, resolveLegendHoverTarget as z };

package/dist/borderRadius.utils-Cz73LLR_.d.mts

@@ -0,0 +1,54 @@
+import { BorderRadius, ResolvedArcBorderRadius, ResolvedBorderRadius } from '@primeui/chart-types';
+
+/**
+ * Resolve border radius configuration to individual corner values.
+ * Handles: undefined, number (uniform), or per-corner object.
+ *
+ * @param borderRadius - Border radius prop (number | BorderRadiusConfig | undefined)
+ * @returns Resolved values for each corner
+ */
+declare function resolveBorderRadius(borderRadius: BorderRadius | undefined): ResolvedBorderRadius;
+/**
+ * Check if any border radius is non-zero.
+ */
+declare function hasBorderRadius(radius: ResolvedBorderRadius): boolean;
+/**
+ * Check if border radius is uniform (all corners same value).
+ */
+declare function isUniformBorderRadius(radius: ResolvedBorderRadius): boolean;
+/**
+ * Clamp border radius values to fit within rectangular dimensions.
+ * Used for bar charts where corners can't exceed half width/height.
+ *
+ * @param radius - Resolved border radius values
+ * @param width - Rectangle width
+ * @param height - Rectangle height
+ * @returns Clamped border radius values
+ */
+declare function clampRectBorderRadius(radius: ResolvedBorderRadius, width: number, height: number): ResolvedBorderRadius;
+/**
+ * Resolve border radius configuration to arc corner values.
+ * Maps standard CSS names to arc-semantic names:
+ * - topLeft → outerStart (where outer arc begins)
+ * - topRight → outerEnd (where outer arc ends)
+ * - bottomLeft → innerStart (where inner arc begins)
+ * - bottomRight → innerEnd (where inner arc ends)
+ */
+declare function resolveArcBorderRadius(borderRadius: BorderRadius | undefined): ResolvedArcBorderRadius;
+/**
+ * Check if any arc border radius is non-zero.
+ */
+declare function hasArcBorderRadius(radius: ResolvedArcBorderRadius): boolean;
+/**
+ * Parse and clamp arc border radius values based on arc geometry.
+ * Ensures corner radii don't exceed available space within the arc.
+ *
+ * @param borderRadius - Border radius prop
+ * @param innerRadius - Inner radius of arc (0 for pie, >0 for donut)
+ * @param outerRadius - Outer radius of arc
+ * @param angleDelta - Angle span in radians
+ * @returns Clamped border radius values
+ */
+declare function clampArcBorderRadius(borderRadius: BorderRadius | undefined, innerRadius: number, outerRadius: number, angleDelta: number): ResolvedArcBorderRadius;
+
+export { clampRectBorderRadius as a, hasBorderRadius as b, clampArcBorderRadius as c, resolveBorderRadius as d, hasArcBorderRadius as h, isUniformBorderRadius as i, resolveArcBorderRadius as r };

package/dist/canvas-D4vigq47.d.mts

@@ -0,0 +1,34 @@
+import { RadialFrameContext, HoverConfig, ChartTheme, SvgNode, SvgSliceRefs, SliceRenderInfo, BoxArea, DataLabelConfig, FieldAccessor } from '@primeui/chart-types';
+
+/** Apply brightness adjustment to SVG gradient stops */
+declare function applyGradientBrightness(pathEl: SVGPathElement, brightness: number): void;
+/** Restore original colors on SVG gradient stops */
+declare function restoreGradientBrightness(pathEl: SVGPathElement): void;
+/** Imperatively update SVG slice elements each animation frame */
+declare function updateSvgSlices(frame: RadialFrameContext, refs: SvgSliceRefs, hoverConfig: HoverConfig | undefined, theme: Required<ChartTheme>, fontFamily?: string): void;
+/** Per-frame custom-render content pass (sibling `customEl` transform/opacity/text). */
+declare function updatePieCustomContent(frame: RadialFrameContext, refs: Pick<SvgSliceRefs, 'customContent' | 'renderFns'>, theme: Required<ChartTheme>, fontFamily?: string): void;
+/**
+ * Build the per-slice SVG descriptors for one pie/donut dataset, from the scene
+ * state. Declarative counterpart to `updateSvgSlices`. The returned nodes are the
+ * children of the `[data-dataset]` group (a `<defs>` first when gradients/clips
+ * exist, then one keyed `<g data-slice-index data-index>` per slice).
+ *
+ * @param frame - Per-frame radial context (slices, center, ring radii, hover state).
+ * @param hoverConfig - Resolved Chart.Hover config (drives brightness / dim / overrides).
+ * @param theme - Resolved chart theme (series palette + hover defaults).
+ * @param chartId - Chart id used to build stable gradient/clip def IDs.
+ * @param datasetIndex - The dataset (ring) whose slices to emit. Slices for other
+ *   datasets in `frame.slices` are skipped (reconcile runs per-dataset-group).
+ */
+declare function buildPieSvgChildren(frame: RadialFrameContext, hoverConfig: HoverConfig | undefined, theme: Required<ChartTheme>, chartId: string, datasetIndex: number): SvgNode[];
+
+/** Render data labels to canvas for pie/donut charts */
+declare function renderCanvasDataLabels(ctx: CanvasRenderingContext2D, frame: RadialFrameContext, viewportBounds: BoxArea, labelConfig: DataLabelConfig, textColor: string, datasetPropsMap: Map<number, {
+    label?: FieldAccessor<unknown, string>;
+    data?: unknown[];
+}>, hoverConfig: HoverConfig | undefined, theme: Required<ChartTheme>, onImageLoad?: () => void): void;
+/** Render custom slice content to canvas */
+declare function renderCanvasCustomContent(ctx: CanvasRenderingContext2D, frame: RadialFrameContext, canvasRenderFns: Map<string, SliceRenderInfo>, onImageLoad: () => void, theme: Required<ChartTheme>, fontFamily?: string): void;
+
+export { renderCanvasDataLabels as a, buildPieSvgChildren as b, updateSvgSlices as c, applyGradientBrightness as d, restoreGradientBrightness as e, renderCanvasCustomContent as r, updatePieCustomContent as u };