@primeui/chart-core 0.0.1-alpha.1

package/dist/sync/index.d.mts

@@ -0,0 +1,130 @@
+import { SyncBusLike, AxisWidths, AxisWidthsCallback, SyncDatasetInfo, ResolvedSyncConfig, SyncExtremesCallback, SyncHighlightCallback, SyncVisibilityCallback, SyncExtremesEvent, SyncHighlightEvent, SyncVisibilityEvent, SyncConfig } from '@primeui/chart-types/sync';
+export { AxisWidths } from '@primeui/chart-types/sync';
+import { ZoomState } from '@primeui/chart-types/zoom';
+import { DatasetRegistration } from '@primeui/chart-types/context';
+import { ChartTheme } from '@primeui/chart-types/theme';
+import { SyncedHighlightResult, RendererDelegate } from '@primeui/chart-types/orchestrator';
+
+/** Resolve user-facing SyncConfig into normalized form */
+declare function resolveSyncConfig(sync: boolean | SyncConfig | undefined): ResolvedSyncConfig;
+/**
+ * SyncBus — coordination bus for multi-chart synchronization.
+ *
+ * Each Chart.Svg / Chart.Canvas registers with a unique chartId and
+ * its resolved sync config. Separate subscribe() calls add listeners
+ * that stack independently — no overwriting.
+ *
+ * When a chart broadcasts an event, the bus forwards it to all other
+ * registered charts that have matching sync config and listeners.
+ */
+declare class SyncBus implements SyncBusLike {
+    private charts;
+    private axisWidthsMap;
+    private _maxAxisWidths;
+    private axisWidthsListeners;
+    /** Publish this chart's natural (un-padded) Y-axis left/right widths. No-op if unchanged. */
+    publishAxisWidths(chartId: string, widths: AxisWidths): void;
+    /** Get the current max axis widths across all registered charts. */
+    getMaxAxisWidths(): AxisWidths;
+    /** Subscribe to max axis width changes. Returns an unsubscribe function. */
+    subscribeAxisWidths(callback: AxisWidthsCallback): () => void;
+    private recomputeMaxAxisWidths;
+    private datasetRegistry;
+    private datasetListeners;
+    /** Register datasets from a chart (for shared legend). Replaces previous entry for this chartId. */
+    registerDatasets(chartId: string, datasets: SyncDatasetInfo[]): void;
+    /** Unregister datasets when a chart unmounts */
+    unregisterDatasets(chartId: string): void;
+    /** Get all registered datasets across all charts */
+    getAllDatasets(): Map<string, SyncDatasetInfo[]>;
+    /** Subscribe to dataset registry changes. Returns unsubscribe function. */
+    subscribeDatasets(callback: () => void): () => void;
+    private notifyDatasetListeners;
+    /** Register a chart instance with its sync config (no callbacks) */
+    register(chartId: string, config: ResolvedSyncConfig): void;
+    /** Subscribe to a sync event type. Returns an unsubscribe function. */
+    subscribe(chartId: string, type: 'extremes', callback: SyncExtremesCallback): () => void;
+    subscribe(chartId: string, type: 'highlight', callback: SyncHighlightCallback): () => void;
+    subscribe(chartId: string, type: 'visibility', callback: SyncVisibilityCallback): () => void;
+    /** Update a chart's sync config (e.g. when sync prop changes) */
+    updateConfig(chartId: string, config: ResolvedSyncConfig): void;
+    /** Unregister a chart instance and all its subscriptions */
+    unregister(chartId: string): void;
+    /** Broadcast an extremes (zoom/pan) event from a source chart */
+    broadcastExtremes(event: SyncExtremesEvent): void;
+    /** Broadcast a highlight (cursor) event from a source chart */
+    broadcastHighlight(event: SyncHighlightEvent): void;
+    /** Broadcast a visibility (series toggle) event from a source chart */
+    broadcastVisibility(event: SyncVisibilityEvent): void;
+    /** Get number of registered charts */
+    get size(): number;
+}
+
+/** Callbacks the framework provides — called by the coordinator when incoming sync events arrive. */
+interface SyncCoordinatorHandlers {
+    applyZoom: (state: ZoomState) => void;
+    applyVisibility: (seriesId: string, visible: boolean) => void;
+    applyItemToggle: (seriesId: string, itemLabel: string) => void;
+    applyHighlight: (result: SyncedHighlightResult) => void;
+}
+/** Lazy getters the coordinator calls at event time to read current framework state. */
+interface SyncCoordinatorRefs {
+    getZoomState: () => ZoomState;
+    getRendererDelegate: () => RendererDelegate | null;
+    getIsCartesian: () => boolean;
+    getIsRect: () => boolean;
+    getHasCrosshair: () => boolean;
+    getIsSharedMode: () => boolean;
+    getDatasets: () => Map<string, DatasetRegistration>;
+    getDimensions: () => {
+        width: number;
+        height: number;
+    };
+}
+type SyncCoordinatorStartOptions = SyncCoordinatorHandlers & SyncCoordinatorRefs;
+/**
+ * Framework-agnostic orchestrator for multi-chart sync.
+ *
+ * Owns the `isSyncing` guard, `prevVisibility` diff map, `prevZoomState`
+ * tracking, and all SyncBus subscription setup.
+ */
+declare class ChartSyncCoordinator {
+    private _isSyncing;
+    private prevVisibility;
+    private prevZoomState;
+    /**
+     * The last zoom value applied from an incoming sync event. Used by onZoomChange
+     * to suppress the echo even when the wrapper's apply effect fires asynchronously
+     * (after the `_isSyncing` microtask reset). Cleared once matched.
+     */
+    private _lastSyncedZoom;
+    private readonly syncInfo;
+    constructor(syncInfo: {
+        bus: SyncBus;
+        chartId: string;
+        config: ResolvedSyncConfig;
+    });
+    get isSyncing(): boolean;
+    /**
+     * Wire up all incoming sync subscriptions.
+     * Call once after constructing the coordinator; store the returned
+     * cleanup function and invoke it on component unmount.
+     */
+    start(options: SyncCoordinatorStartOptions): () => void;
+    /** Re-register datasets with the shared legend bus. Call whenever datasets or theme change. */
+    updateDatasets(datasets: Map<string, DatasetRegistration>, theme: Required<ChartTheme>): void;
+    /**
+     * Broadcast zoom state changes to other charts.
+     * Always call this when zoom state changes — the guard is handled internally.
+     */
+    onZoomChange(current: ZoomState): void;
+    /**
+     * Diff visibility state and broadcast changes to other charts.
+     * Always call this on visibility change — guard and diffing are handled internally.
+     * prevVisibility is always updated regardless of isSyncing to prevent stale state
+     * on the next outgoing broadcast.
+     */
+    onVisibilityChange(visibility: Map<string, boolean>): void;
+}
+
+export { ChartSyncCoordinator, SyncBus, type SyncCoordinatorHandlers, type SyncCoordinatorRefs, type SyncCoordinatorStartOptions, resolveSyncConfig };

package/dist/sync/index.mjs

@@ -0,0 +1,5 @@
+export { ChartSyncCoordinator, SyncBus, resolveSyncConfig } from '../chunk-BABQKA6K.mjs';
+import '../chunk-WYLILAOO.mjs';
+import '../chunk-O2X6FF45.mjs';
+import '../chunk-SSLTFJ3U.mjs';
+import '../chunk-RQ3CKQOX.mjs';

package/dist/tooltip.renderer-D5wpSlBa.d.mts

@@ -0,0 +1,210 @@
+import { CartesianFrameParams, CartesianOverlayParams, ResolvedLabel, FrameDataLabelConfig, RenderLabelsOptions, RadarDatasetEntry, BoxArea, GlobalFont, RadarRenderData, PolarDatasetEntry, FieldAccessor, RadialHoverState, ChartTheme, StandardEffectConfig, RadarSeriesProps, PointDescriptionContext, SvgNode, StandardHitTestResult, RadialLayoutBase, XAxisProps, YAxisProps, RadialGridLayout, RadialGridConfig, TooltipData, TooltipValueFormatter, TooltipContent } from '@primeui/chart-types';
+
+declare function renderResolvedLabels(labels: ResolvedLabel[], config: FrameDataLabelConfig, options: RenderLabelsOptions): void;
+/**
+ * Renders cartesian chrome: grid → background fills → reference lines/bands → axes → brackets.
+ * Bar/line/scatter/candlestick/heatmap rendering is handled by their independent hooks.
+ * Used by the animation callback, static render path, and hover repaint.
+ *
+ * SVG path:    accumulates SvgNode children into two virtual roots (gridRoot, mainRoot),
+ *              then replaces each group's DOM content atomically via replaceGroupContent.
+ *              The repeated `group.appendChild(materializeSvgGroup(x))` pattern is unified
+ *              into `addNode(root, x)` throughout — one materialization per group at the end.
+ * Canvas path: imperative ctx draw calls, unchanged.
+ */
+declare function renderCartesianFrame(params: CartesianFrameParams): void;
+/**
+ * Draw all custom render callbacks for cartesian charts on the overlay canvas.
+ * Handles: render/renderTick (axes), line renderMarker (custom markers).
+ * Uses the generic renderCanvasOverlay for clear/clip/animate infrastructure.
+ */
+declare function renderCartesianOverlay(params: CartesianOverlayParams): void;
+
+/**
+ * Calculate the complete radar chart layout from multiple datasets.
+ *
+ * **Angle math:**
+ * - Each category gets an equal slice: angleStep = 360 / categoryCount
+ * - First spoke starts at -90° (12 o'clock), going clockwise
+ * - Category i is at angle: -90 + i * angleStep
+ *
+ * **Radial value mapping:**
+ * - Domain [0, niceMax] computed via calculateNiceDomain
+ * - Value maps to radius: r = ((value - min) / (max - min)) * maxRadius
+ * - value=0 → center, value=max → perimeter
+ *
+ * **Polar → Cartesian:**
+ * - x = center.x + cos(angleRad) * r
+ * - y = center.y + sin(angleRad) * r
+ */
+declare function calculateRadarLayout(datasets: RadarDatasetEntry[], chartArea: BoxArea, globalFont?: GlobalFont, sharedCategories?: string[], sharedDomain?: [number, number], perAxisDomains?: Map<string, [number, number]>, referenceBoundaryValues?: number[], perSpokeDomains?: Map<number, [number, number]>, tickCount?: number): Omit<RadarRenderData, 'datasetIndex'>;
+/**
+ * Extract merged category list from all datasets (preserving first dataset's order).
+ * Exported for reuse by polar renderer.
+ */
+declare function extractCategories(datasets: {
+    props: {
+        data?: unknown[];
+        categoryField?: FieldAccessor<unknown, string>;
+    };
+}[]): string[];
+/**
+ * Resolve numeric values from a dataset's props.
+ * Exported for reuse by polar renderer.
+ */
+declare function resolveValues(props: {
+    data?: unknown[];
+    valueField?: FieldAccessor<unknown, number>;
+}): number[];
+/**
+ * Compute a shared category list and value domain from a mix of radar and polar datasets.
+ * Used when both types coexist in one chart so they share the same radial grid.
+ */
+declare function computeRadialComboContext(radarDatasets: RadarDatasetEntry[], polarDatasets: PolarDatasetEntry[]): {
+    categories: string[];
+    domain: [number, number];
+};
+/**
+ * Determine text-anchor for a category label based on its spoke angle.
+ * Right hemisphere → 'start', left hemisphere → 'end', top/bottom → 'middle'
+ */
+declare function getCategoryLabelAnchor(angleDeg: number): string;
+/**
+ * Calculate per-side label margins based on actual category text.
+ *
+ * For each label we compute how far it extends beyond the grid perimeter
+ * in each cardinal direction, accounting for measured text dimensions,
+ * text-anchor assignment, and the text-derived labelPadding gap.
+ */
+/**
+ * Calculate per-side label margins based on actual category text at each spoke.
+ * Exported for reuse by polar renderer.
+ */
+declare function calculateLabelMargins(categories: string[], angleStep: number, labelPadding: number, fontSize?: number): {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+
+/**
+ * Render a single radar series as SVG (polygon fill + stroke + markers)
+ */
+declare function renderRadarSeriesSvg(layout: RadarRenderData, seriesIndex: number, hoverState: RadialHoverState, theme: Required<ChartTheme>, effectConfig?: StandardEffectConfig, seriesProps?: RadarSeriesProps, a11y?: {
+    enabled: boolean;
+    pointDescriptionThreshold: number;
+    pointDescriptionFormatter?: (ctx: PointDescriptionContext) => string;
+}, context?: {
+    chartId: string;
+}): SvgNode;
+
+/**
+ * Render a single radar series to canvas
+ */
+declare function renderRadarSeriesCanvas(ctx: CanvasRenderingContext2D, layout: RadarRenderData, seriesIndex: number, hoverState: RadialHoverState, effectConfig: StandardEffectConfig | undefined, seriesProps: RadarSeriesProps | undefined, theme: Required<ChartTheme>): void;
+
+/**
+ * Find the nearest radar point to the given coordinates.
+ * Returns the dataset ID and point index, or null if no point is within hit radius.
+ */
+declare function hitTestRadar(x: number, y: number, layout: RadarRenderData, theme: Required<ChartTheme>): StandardHitTestResult | null;
+
+/**
+ * Resolves XAxis/YAxis props into a fully-defaulted RadialGridLayout.
+ *
+ * - Returns `xAxis: null` when `xAxisProps` is undefined (ChartXAxis not declared)
+ *   → renderer skips spoke labels and outer ring.
+ * - Returns `yAxis: null` when `yAxisProps` is undefined and no per-spoke yAxes declared
+ *   → renderer skips concentric rings and tick labels.
+ *
+ * Mode selection:
+ * - Shared (`yAxis.mode === 'shared'`): single value scale across all spokes.
+ *   Active when `base.perSpokeDomains` is null/undefined.
+ * - Per-spoke (`yAxis.mode === 'perSpoke'`): each spoke has its own scale.
+ *   Active when `base.perSpokeDomains` is set (controller detected at least one
+ *   ChartYAxis with a `category` binding).
+ *
+ * Tick-hop (shared mode only): when the outermost tick sits at or below the data max,
+ * extends the domain by one tick step so the perimeter doesn't visually touch the data.
+ *  - If `yAxisProps.tickCount` is set → re-runs generateNiceTicks(min, extended, count, exact=true)
+ *  - Otherwise → appends one tick at lastTick + tickStep
+ *
+ * Per-spoke mode: each spoke's tick set is generated independently from its own domain.
+ * Per-spoke styling falls back to the default `yAxisProps`; declared category-bound
+ * yAxes override font/color/tickFormat for that spoke specifically.
+ */
+/**
+ * Resolve the settled shared-mode radial tick set (values + radii + tick-aligned domain).
+ *
+ * Single source of truth shared by buildRadialGridLayout (settled render) and the radial
+ * controllers (which slide this exact set during a transition). Keeping it in one place
+ * guarantees the animation lands precisely on the settled grid — no end-of-zoom pop.
+ *
+ *  - `tickCount` set (>=2) → exactly that many nice ticks pinned to the raw data max.
+ *  - otherwise → tick-hop: extend by one step when the outer tick sits at/below the data max.
+ */
+declare function resolveSharedRadialGrid(grid: RadialGridConfig, domain: [number, number], rawDataMax: number | undefined, radius: number, tickCount?: number): {
+    levelValues: number[];
+    levelRadii: number[];
+    domain: [number, number];
+};
+declare function buildRadialGridLayout(base: RadialLayoutBase, xAxisProps: XAxisProps | undefined, yAxisProps: YAxisProps | undefined, yAxesByCategory?: Map<string, YAxisProps>, chartType?: 'radar' | 'polar'): RadialGridLayout;
+
+declare function renderRadialGridSvg(layout: RadialGridLayout, theme: Required<ChartTheme>, axisIndex?: number): SvgNode;
+
+declare function renderRadialGridCanvas(ctx: CanvasRenderingContext2D, layout: RadialGridLayout, theme: Required<ChartTheme>, axisIndex?: number): void;
+/**
+ * Full canvas redraw pipeline for the radial renderer.
+ *
+ * Framework layers call this whenever any composable/hook needs a canvas
+ * repaint (data change, hover, animation frame).
+ */
+declare function redrawRadialCanvas(ctx: CanvasRenderingContext2D, canvas: HTMLCanvasElement, gridLayout: RadialGridLayout | null, renderPolarContent: ((ctx: CanvasRenderingContext2D, canvas: HTMLCanvasElement) => void) | null, renderRadarContent: ((ctx: CanvasRenderingContext2D, canvas: HTMLCanvasElement) => void) | null, theme: Required<ChartTheme>): void;
+
+interface BuildTooltipOptions {
+    locale?: string;
+    valueFormatter?: TooltipValueFormatter;
+}
+/**
+ * Build a structured tooltip content descriptor from tooltip state.
+ * Framework renderers use this to render the appropriate layout
+ * without duplicating branching logic.
+ */
+declare function buildTooltipContent(data: TooltipData, isSharedMode: boolean, opts?: BuildTooltipOptions): TooltipContent;
+type TooltipPosition = 'cursor' | 'top' | 'bottom' | 'left' | 'right';
+interface TooltipPositionInput {
+    position: TooltipPosition;
+    /** Cursor point the core reports (already includes the +10 hit-test nudge). */
+    cursorX: number;
+    cursorY: number;
+    offsetX: number;
+    offsetY: number;
+    /** Measured rendered tooltip size; 0 when not yet measured (clamping is skipped). */
+    tooltipWidth: number;
+    tooltipHeight: number;
+    containerWidth: number;
+    containerHeight: number;
+    isSharedMode: boolean;
+    rtl: boolean;
+}
+/** Positioning fields to spread onto the tooltip element's style (over `TOOLTIP_BASE_STYLE`). */
+interface TooltipPositionStyle {
+    left?: string;
+    top?: string;
+    right?: string;
+    bottom?: string;
+    transform?: string;
+    transition?: string;
+}
+/**
+ * Compute the tooltip element's positioning style — framework-agnostic.
+ *
+ * Handles the five `position` modes plus smart boundary clamping for the default
+ * `cursor` mode (flips the tooltip to the other side of the cursor when it would
+ * overflow the chart, falling back to a no-clamp follow when dimensions are
+ * unknown). Returns only the position-specific fields; callers spread them over
+ * `TOOLTIP_BASE_STYLE` (+ appearance).
+ */
+declare function computeTooltipPosition(input: TooltipPositionInput): TooltipPositionStyle;
+
+export { type TooltipPosition as T, buildTooltipContent as a, buildRadialGridLayout as b, calculateRadarLayout as c, computeRadialComboContext as d, computeTooltipPosition as e, renderCartesianFrame as f, renderCartesianOverlay as g, hitTestRadar as h, renderRadarSeriesCanvas as i, renderRadarSeriesSvg as j, renderRadialGridCanvas as k, renderRadialGridSvg as l, renderResolvedLabels as m, resolveSharedRadialGrid as n, type TooltipPositionInput as o, type TooltipPositionStyle as p, calculateLabelMargins as q, redrawRadialCanvas as r, extractCategories as s, getCategoryLabelAnchor as t, resolveValues as u };

package/dist/utils/color/index.d.mts

@@ -0,0 +1,58 @@
+export { C as ColorParser, D as DEFAULT_HEAT_COLORS, R as RGBA, a as adjustBrightness, b as asGradient, y as brightenGradientStops, c as buildAutoColorScale, d as createCanvasGradientFromColor, e as createSvgGradientFromColor, g as getColor, f as getColorValue, h as getPrimaryColor, i as gradientToCssBackground, m as hexToRgbString, n as hexToRgba, j as interpolateColor, o as isGradientColor, l as lerpColor, q as normalizeGradient, t as parseColorToRGB, p as parseColorToRGBA, u as parseHexColor, v as remapStopsForDonut, w as resolveColorScaleRange, r as resolveSwatchColor, k as resolveSwatchGradientStops, x as sampleGradientAt, s as setColorParser } from '../../scale-KFv30jqZ.mjs';
+import { ColorValue } from '@primeui/chart-types';
+
+/**
+ * Calculate relative luminance from RGB values.
+ * Uses ITU-R BT.709 formula (W3C WCAG standard) for perceived brightness.
+ *
+ * @param r - Red component (0-255)
+ * @param g - Green component (0-255)
+ * @param b - Blue component (0-255)
+ * @returns Luminance value 0-1 (0 = black, 1 = white)
+ */
+declare function calculateLuminanceFromRGB(r: number, g: number, b: number): number;
+/**
+ * Perceived brightness via the YIQ / Rec. 601 luma formula (0–1).
+ *
+ * This is the single source for TEXT-CONTRAST decisions (which label color is legible on a
+ * background) — deliberately kept distinct from `calculateLuminanceFromRGB` (BT.709 relative
+ * luminance). All contrast helpers (`getContrastColor`, `isColorDark`) route through this so
+ * the "is this background dark?" decision is consistent everywhere.
+ *
+ * @returns Perceived brightness 0-1 (0 = black, 1 = white)
+ */
+declare function perceivedLuminanceFromRGB(r: number, g: number, b: number): number;
+/**
+ * Calculate relative luminance of a color.
+ * Uses ITU-R BT.709 formula for perceived brightness.
+ *
+ * @param color - CSS color string
+ * @returns Luminance value 0-1 (0 = black, 1 = white), or 0.5 if parsing fails
+ */
+declare function getColorLuminance(color: string): number;
+/**
+ * Calculate weighted average luminance of gradient stops.
+ *
+ * @param stops - Array of gradient stops with offset and color
+ * @returns Average luminance 0-1
+ */
+declare function getGradientLuminance(stops: Array<{
+    offset: number;
+    color: string;
+}>): number;
+/**
+ * Get a contrasting text color for a given background color.
+ * Returns white for dark backgrounds, dark gray for light backgrounds.
+ *
+ * @param bgColor - Background ColorValue (string or gradient)
+ * @param threshold - Luminance threshold (default 0.5)
+ * @returns Contrasting text color string
+ */
+declare function getContrastingTextColor(bgColor: ColorValue, threshold?: number): string;
+/**
+ * Returns a readable text color ('#FFFFFF' or '#374151') based on background luminance.
+ * Uses WCAG relative luminance formula.
+ */
+declare function getContrastColor(bgColor: string): string;
+
+export { calculateLuminanceFromRGB, getColorLuminance, getContrastColor, getContrastingTextColor, getGradientLuminance, perceivedLuminanceFromRGB };

package/dist/utils/color/index.mjs

@@ -0,0 +1,4 @@
+export { DEFAULT_HEAT_COLORS, buildAutoColorScale, calculateLuminanceFromRGB, getColorLuminance, getContrastColor, getContrastingTextColor, getGradientLuminance, interpolateColor, lerpColor, perceivedLuminanceFromRGB, resolveColorScaleRange } from '../../chunk-QS76E3TD.mjs';
+export { asGradient, createCanvasGradientFromColor, createSvgGradientFromColor, getColor, getColorValue, getPrimaryColor, gradientToCssBackground, isGradientColor, normalizeGradient, remapStopsForDonut, resolveSwatchColor, resolveSwatchGradientStops, sampleGradientAt } from '../../chunk-O2X6FF45.mjs';
+export { adjustBrightness, brightenGradientStops, hexToRgbString, hexToRgba, parseColorToRGB, parseColorToRGBA, parseHexColor, setColorParser } from '../../chunk-SSLTFJ3U.mjs';
+import '../../chunk-RQ3CKQOX.mjs';

package/dist/utils/data/index.d.mts

@@ -0,0 +1,180 @@
+import { TimeUnit, TimeInterval, TimeTickConfig, DateTimeFormatConfig, AggregationMethod, CartesianDomainParams, DomainSeries, DomainContribution, VisibleValuesSeries, ScatterDatasetInfo, AxisConfig } from '@primeui/chart-types';
+export { c as collectItems } from '../../collect.utils-DiKB4ciO.mjs';
+
+/** Millisecond values for each time unit */
+declare const MS: {
+    readonly millisecond: 1;
+    readonly second: 1000;
+    readonly minute: 60000;
+    readonly hour: 3600000;
+    readonly day: 86400000;
+    readonly week: 604800000;
+    readonly month: 2592000000;
+    readonly quarter: 7776000000;
+    readonly year: 31536000000;
+};
+/**
+ * Ordered list of candidate tick intervals (Highcharts-style).
+ * selectTickInterval() picks the finest interval where tick count
+ * stays ≤ pixelWidth / minSpacing.
+ */
+declare const TICK_INTERVALS: TimeInterval[];
+/**
+ * Default Intl.DateTimeFormatOptions per unit (Highcharts dateTimeLabelFormats style).
+ */
+declare const DEFAULT_FORMATS: Record<TimeUnit, Intl.DateTimeFormatOptions>;
+/**
+ * Convert any date-like value to millisecond timestamp.
+ * Supports: Date objects, ISO strings, numeric timestamps.
+ * Returns NaN for invalid input.
+ */
+declare function toTimestamp(value: unknown): number;
+/** Approximate ms span for a given interval (for counting ticks) */
+declare function intervalSpanMs(interval: TimeInterval): number;
+/**
+ * Pick the finest interval where tick count ≤ pixelWidth / minSpacing.
+ */
+declare function selectTickInterval(domainSpanMs: number, pixelWidth: number, config?: TimeTickConfig): TimeInterval;
+/**
+ * Floor a timestamp to the nearest boundary for a given unit and multiple.
+ * Uses UTC internally for consistent results.
+ *
+ * @example
+ * floorToUnit(Date.parse('2024-01-15T14:30:00Z'), 'hour', 1)
+ * // → 2024-01-15T14:00:00Z
+ *
+ * floorToUnit(Date.parse('2024-03-15'), 'month', 1)
+ * // → 2024-03-01T00:00:00Z
+ */
+declare function floorToUnit(timestamp: number, unit: TimeUnit, multiple: number): number;
+/**
+ * Advance a timestamp by N units, handling variable-length months/years.
+ */
+declare function advanceByUnit(timestamp: number, unit: TimeUnit, count: number): number;
+
+declare function generateTimeTicks(min: number, max: number, pixelWidth: number, config?: TimeTickConfig): {
+    ticks: number[];
+    interval: TimeInterval;
+};
+/**
+ * Format a timestamp for a given time unit.
+ * Uses Intl.DateTimeFormat with caching for performance.
+ */
+declare function formatTimeTick(timestamp: number, unit: TimeUnit, timezone?: string, overrides?: DateTimeFormatConfig, locale?: string): string;
+/**
+ * Detect which time unit ticks correspond to based on average interval.
+ */
+declare function detectTickUnit(ticks: number[]): TimeUnit;
+/**
+ * Check if a timestamp is at a period boundary of a higher-level unit.
+ * Returns the parent unit if at boundary, null otherwise.
+ *
+ * Used for richer labels at boundaries:
+ * - Ticks are hours, midnight → show date ("Jan 15")
+ * - Ticks are days, Jan 1 → show year ("2024")
+ * - Ticks are months, Jan → show year ("2024")
+ */
+declare function isPeriodBoundary(timestamp: number, tickUnit: TimeUnit): TimeUnit | null;
+
+declare function buildOrdinalTimeMapping(timestamps: number[]): {
+    /** Sorted unique timestamps */
+    sortedTimestamps: number[];
+    /** Get the ordinal index for a timestamp (binary search) */
+    indexOf: (timestamp: number) => number;
+    /** Get the timestamp at an ordinal index */
+    timestampAt: (index: number) => number;
+};
+/**
+ * Auto-select bucket size to reduce point count below threshold.
+ */
+declare function selectGroupingInterval(domainSpanMs: number, dataLength: number, targetPoints: number): TimeInterval;
+/**
+ * Group data points by time interval and apply aggregation.
+ *
+ * @param data - Raw data array
+ * @param categoryAccessor - Field name for timestamp (e.g., "date")
+ * @param valueAccessor - Field name for numeric value (e.g., "close")
+ * @param interval - Grouping interval
+ * @param method - Aggregation method
+ * @returns New data array with aggregated values
+ */
+declare function groupTimeData<T extends Record<string, unknown>>(data: T[], categoryAccessor: string, valueAccessor: string, interval: TimeInterval, method: AggregationMethod): T[];
+
+/**
+ * Merge multiple domain contributions into unified domain maps.
+ * Per axis: expand to encompass all contributions, then re-nice.
+ *
+ * @param baseDomains - Existing value domains (e.g., from bar pipeline). Mutated in place.
+ * @param contributions - Domain contributions from line, scatter, candlestick, etc.
+ * @returns The merged scatter X domains (new map).
+ */
+declare function mergeDomainContributions(baseDomains: Map<string, [number, number]>, contributions: DomainContribution[]): Map<string, [number, number]>;
+/**
+ * Compute the unified value domain for a cartesian chart.
+ * Considers all stacking modes, hidden datasets, and expands
+ * domain to encompass generated tick values for grid alignment.
+ */
+declare function computeCartesianDomain(params: CartesianDomainParams): [number, number];
+/**
+ * Merge values into an existing domain map for a given axis.
+ * If the axis already has a domain, expand it. Otherwise create a new one.
+ */
+declare function expandDomainWithValues(valueDomains: Map<string, [number, number]>, axisId: string, values: number[], includeZero: boolean): void;
+/**
+ * Resolve whether a dataset's target axis should include zero in its domain.
+ * Logic: explicit startFromZero > hasBarsOnAxis (bars anchor to zero) > false (lines/areas fit to data range).
+ */
+declare function resolveIncludeZero(targetAxisId: string, valueAxes: Map<string, AxisConfig>, barAxisIds: Set<string>): boolean;
+/**
+ * Compute a domain contribution from pre-resolved series data.
+ * Generic — works for any chart type. Callers resolve their own values
+ * (handling stacking, accessors, etc.) into DomainSeries arrays.
+ *
+ * @param valueSeries - Value axis series (Y for vertical, X for horizontal)
+ * @param categorySeries - Category-side linear series (scatter X). Optional.
+ */
+declare function computeDomainContribution(valueSeries: DomainSeries[], categorySeries?: DomainSeries[]): DomainContribution;
+/**
+ * Compute visible Y values within a zoom window for adaptive Y-axis.
+ * Generic — works for any chart type. Callers resolve their own X/Y arrays
+ * into VisibleValuesSeries.
+ *
+ * @returns Map of axis ID → visible Y values within [xMin, xMax]
+ */
+declare function computeVisibleValues(series: VisibleValuesSeries[], xMin: number, xMax: number): Map<string, number[]>;
+/**
+ * Expand scatter X and Y domains with bubble padding so outermost markers
+ * don't clip outside the chart area. Converts marker pixel radius to data-space padding.
+ */
+declare function expandScatterBubblePadding(params: {
+    scatterDatasets: ScatterDatasetInfo[];
+    valueDomains: Map<string, [number, number]>;
+    scatterXDomains: Map<string, [number, number]>;
+    firstValueAxisId: string;
+    firstCategoryAxisId: string;
+    chartArea: {
+        width: number;
+        height: number;
+    };
+    isLogValueAxis?: (axisId: string) => boolean;
+    isLogCategoryAxis?: (axisId: string) => boolean;
+}): void;
+/**
+ * Expand value domains so outside data labels don't clip at the chart edge.
+ * Skipped when a custom render function is set (unknown size), on log axes,
+ * and for percent-stacked axes (domain is fixed [0, 100]).
+ */
+declare function expandDataLabelPadding(params: {
+    valueDomains: Map<string, [number, number]>;
+    dataLabelFontSize: number;
+    orientation: 'vertical' | 'horizontal';
+    chartArea: {
+        width: number;
+        height: number;
+    };
+    axisIds: Iterable<string>;
+    isLogAxis?: (axisId: string) => boolean;
+    isPercentStackedAxis?: (axisId: string) => boolean;
+}): void;
+
+export { DEFAULT_FORMATS, MS, TICK_INTERVALS, advanceByUnit, buildOrdinalTimeMapping, computeCartesianDomain, computeDomainContribution, computeVisibleValues, detectTickUnit, expandDataLabelPadding, expandDomainWithValues, expandScatterBubblePadding, floorToUnit, formatTimeTick, generateTimeTicks, groupTimeData, intervalSpanMs, isPeriodBoundary, mergeDomainContributions, resolveIncludeZero, selectGroupingInterval, selectTickInterval, toTimestamp };

package/dist/utils/data/index.mjs

@@ -0,0 +1,7 @@
+export { buildOrdinalTimeMapping, computeCartesianDomain, computeDomainContribution, computeVisibleValues, expandDataLabelPadding, expandDomainWithValues, expandScatterBubblePadding, groupTimeData, mergeDomainContributions, resolveIncludeZero, selectGroupingInterval } from '../../chunk-22ST6YPP.mjs';
+export { collectItems } from '../../chunk-FFMT6OCO.mjs';
+import '../../chunk-NKUYIWAP.mjs';
+import '../../chunk-QS76E3TD.mjs';
+import '../../chunk-O2X6FF45.mjs';
+import '../../chunk-SSLTFJ3U.mjs';
+export { DEFAULT_FORMATS, MS, TICK_INTERVALS, advanceByUnit, detectTickUnit, floorToUnit, formatTimeTick, generateTimeTicks, intervalSpanMs, isPeriodBoundary, selectTickInterval, toTimestamp } from '../../chunk-RQ3CKQOX.mjs';

package/dist/utils/export/index.d.mts

@@ -0,0 +1,14 @@
+import { ChartExportMethods } from '@primeui/chart-types';
+
+/**
+ * Create chart export functions for a container
+ *
+ * @param container - Container element holding the chart
+ * @param width - Chart width
+ * @param height - Chart height
+ * @param renderer - Current renderer type ('svg' or 'canvas')
+ * @returns Export methods (toImage, toDataURL, toBlob)
+ */
+declare function createChartExporter(container: HTMLElement, width: number, height: number, renderer: 'svg' | 'canvas'): ChartExportMethods;
+
+export { createChartExporter };

package/dist/utils/export/index.mjs

@@ -0,0 +1,6 @@
+export { createChartExporter } from '../../chunk-ARRGOEFX.mjs';
+import '../../chunk-NKUYIWAP.mjs';
+import '../../chunk-QS76E3TD.mjs';
+import '../../chunk-O2X6FF45.mjs';
+import '../../chunk-SSLTFJ3U.mjs';
+import '../../chunk-RQ3CKQOX.mjs';