@primeui/chart-core 0.0.1-alpha.1

package/dist/datalabel.utils-CkjGeB8S.d.mts

@@ -0,0 +1,122 @@
+import { TextMeasurer, BoxArea, TitleRenderConfig, SvgNode, DataLabelConfig, GlobalFont } from '@primeui/chart-types';
+
+/** Average character width as a fraction of font size (bold proportional ~0.65) */
+declare const CHAR_WIDTH_RATIO = 0.65;
+type TextAnchor = 'start' | 'middle' | 'end';
+/** Get X position for title based on alignment */
+declare function getTitleX(titleArea: BoxArea, align: 'left' | 'center' | 'right'): number;
+/** Get Y position for title (vertically centered) */
+declare function getTitleY(titleArea: BoxArea): number;
+/** Convert alignment to SVG text-anchor value */
+declare function getTitleAnchor(align: 'left' | 'center' | 'right'): TextAnchor;
+/** Render title on canvas — alphabetic baseline + rounded final Y matches createSvgTitle */
+declare function renderCanvasTitle(ctx: CanvasRenderingContext2D, titleArea: BoxArea | undefined, config: TitleRenderConfig, textColor: string): void;
+/** Create SVG title element */
+declare function createSvgTitle(titleArea: BoxArea | undefined, config: TitleRenderConfig): SvgNode | null;
+/**
+ * Override the text measurement implementation.
+ * Call this before any chart rendering to inject a custom measurer
+ * (e.g., for SSR, Web Workers, or testing with predictable widths).
+ *
+ * @example
+ * ```typescript
+ * // SSR: use approximate character-width estimation
+ * setTextMeasurer({
+ *     measureWidth: (text, fontSize) => text.length * fontSize * 0.55
+ * });
+ *
+ * // Testing: predictable widths
+ * setTextMeasurer({
+ *     measureWidth: (text, fontSize) => text.length * fontSize * 0.6
+ * });
+ *
+ * // Reset to default browser measurer
+ * setTextMeasurer(null);
+ * ```
+ */
+declare function setTextMeasurer(measurer: TextMeasurer | null): void;
+/**
+ * Measures the width of text with the given font.
+ * Results are cached with LRU eviction to avoid repeated operations.
+ * Uses the active TextMeasurer (browser canvas by default, injectable).
+ */
+declare function measureTextWidth(text: string, fontSize: number, fontWeight?: string, fontFamily?: string): number;
+/**
+ * Measures text dimensions including width and approximate height
+ */
+declare function measureText(text: string, fontSize: number, fontFamily?: string): {
+    width: number;
+    height: number;
+};
+/**
+ * Returns the font's em-box ascent and descent relative to the alphabetic baseline.
+ * These values match Canvas `fontBoundingBoxAscent` / `fontBoundingBoxDescent`, which
+ * are the same offsets Canvas uses when `textBaseline = 'top'` or `'middle'`.
+ *
+ * Used to compute pixel-exact `dy` offsets for SVG text so it renders at the same
+ * position as Canvas text rendered with `textBaseline = 'top'` or `'middle'`.
+ *
+ * Falls back to font-size ratio estimates if the Canvas API isn't available or
+ * `fontBoundingBoxAscent` is unsupported.
+ */
+declare function measureFontMetrics(fontSize: number, fontFamily: string, fontWeight?: string): {
+    topToAlpha: number;
+    midToAlpha: number;
+};
+/**
+ * Wraps text to fit within a maximum width
+ * Returns an array of lines
+ *
+ * Rules:
+ * - Only wraps at word boundaries (spaces)
+ * - Never breaks individual words, even if they exceed maxWidth
+ * - Single words are returned as-is regardless of width
+ */
+declare function wrapText(text: string, maxWidth: number, fontSize: number, fontFamily?: string, fontWeight?: string): string[];
+/**
+ * Calculates the total height of wrapped text
+ */
+declare function calculateWrappedTextHeight(lines: string[], fontSize: number, lineHeightMultiplier?: number): number;
+/**
+ * Calculates the maximum width among wrapped lines
+ */
+declare function calculateWrappedTextWidth(lines: string[], fontSize: number, fontFamily?: string, fontWeight?: string): number;
+/**
+ * Cleanup function for SSR or test environments.
+ * Releases the cached canvas context to allow garbage collection.
+ */
+declare function cleanupMeasureContext(): void;
+/**
+ * Clears the text width cache.
+ * Useful when font loading completes or for testing.
+ */
+declare function clearTextWidthCache(): void;
+/**
+ * Format a numeric value compactly for display on chart axes, grids, and labels.
+ * When a locale is provided, uses `Intl.NumberFormat` with compact notation
+ * for locale-aware suffixes (e.g. "12K" in English, "12.000" in German).
+ * Without locale, falls back to manual formatting.
+ */
+declare function formatCompactValue(v: number, locale?: string): string;
+/**
+ * Convert SVG text-anchor value to Canvas textAlign.
+ * SVG uses 'start' | 'middle' | 'end', Canvas uses 'left' | 'center' | 'right'.
+ */
+declare function svgAnchorToCanvasAlign(anchor: string): CanvasTextAlign;
+
+/**
+ * Normalize data label props to a consistent configuration object.
+ * Shared by both Canvas and SVG renderers across all frameworks.
+ *
+ * Framework wrappers may extend the returned config with framework-specific
+ * fields (e.g., React adds `render?: (ctx) => ReactNode`).
+ *
+ * @param props - Raw data labels props from the DataLabels component
+ * @param adaptiveFontSize - Responsive system's adaptive font size (used when user hasn't set explicit fontSize)
+ * @param adaptiveRotation - Responsive system's adaptive rotation (used when user hasn't set explicit rotation)
+ * @returns Normalized configuration with defaults applied
+ */
+declare function normalizeDataLabelConfig(props: Record<string, unknown> | undefined, adaptiveFontSize?: number, adaptiveRotation?: number, globalFont?: GlobalFont): DataLabelConfig | null;
+declare function formatDataLabelText(value: number, percentage: number, display: DataLabelConfig['display'], formatter?: DataLabelConfig['formatter'], label?: string): string | null;
+
+export { CHAR_WIDTH_RATIO as C, formatDataLabelText as a, calculateWrappedTextWidth as b, calculateWrappedTextHeight as c, cleanupMeasureContext as d, clearTextWidthCache as e, formatCompactValue as f, createSvgTitle as g, getTitleAnchor as h, getTitleX as i, getTitleY as j, measureTextWidth as k, svgAnchorToCanvasAlign as l, measureText as m, normalizeDataLabelConfig as n, measureFontMetrics as o, renderCanvasTitle as r, setTextMeasurer as s, wrapText as w };

package/dist/decimation.utils-CcvJVhI4.d.mts

@@ -0,0 +1,244 @@
+import { ExportMenuItem, ExportItemAction, ExportMenuProps, DrilldownState, DrilldownTree, DrilldownBreadcrumb, DrilldownNode, ScatterDecimationEntry, ScatterDecimationConfig, ZoomRange, DecimationConfig } from '@primeui/chart-types';
+import { DatasetRegistration } from '@primeui/chart-types/context';
+
+declare const EXPORT_MENU_CONSTANTS: {
+    /** Button size in pixels */
+    readonly BUTTON_SIZE: 36;
+    /** Button padding */
+    readonly BUTTON_PADDING: 8;
+    /** Menu width */
+    readonly MENU_WIDTH: 180;
+    /** Menu item height */
+    readonly MENU_ITEM_HEIGHT: 32;
+    /** Separator height */
+    readonly SEPARATOR_HEIGHT: 1;
+    /** Menu border radius */
+    readonly BORDER_RADIUS: 4;
+    /** Z-index for menu overlay */
+    readonly Z_INDEX: 1000;
+};
+declare const DEFAULT_EXPORT_MENU_ITEMS: ExportMenuItem[];
+declare const DEFAULT_EXPORT_MENU_PROPS: Required<Omit<ExportMenuProps, 'menuItems'>> & {
+    menuItems: ExportMenuItem[];
+};
+declare const EXPORT_MENU_LABELS: Record<Exclude<ExportMenuItem, 'separator'>, string>;
+/** SVG path data for hamburger menu icon */
+declare const HAMBURGER_ICON_PATH = "M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z";
+/**
+ * Merge user props with defaults
+ */
+declare function resolveExportMenuProps(props: ExportMenuProps): typeof DEFAULT_EXPORT_MENU_PROPS;
+/**
+ * Check if menu item is a separator
+ */
+declare function isExportMenuSeparator(item: ExportMenuItem): item is 'separator';
+/**
+ * Filter menu items based on renderer type.
+ * All formats work for both renderers — canvas SVG export composites layers
+ * into a PNG embedded inside an SVG wrapper (same approach as amCharts).
+ * Only cleans up orphaned separators.
+ */
+declare function filterExportMenuItems(items: ExportMenuItem[]): ExportMenuItem[];
+/**
+ * Estimate menu height from its item list. The menu has fixed inline styles,
+ * so this is deterministic — avoids a DOM measure round-trip.
+ */
+declare function estimateExportMenuHeight(items: ExportMenuItem[]): number;
+interface ExportMenuPlacementInput {
+    align: 'left' | 'right';
+    verticalAlign: 'top' | 'bottom';
+    /** Horizontal offset as configured on the button (can be negative) */
+    x: number;
+    /** Vertical offset as configured on the button (can be negative) */
+    y: number;
+    buttonSize: number;
+    menuWidth: number;
+    menuHeight: number;
+    chartWidth: number;
+    chartHeight: number;
+    /** Space between button and menu. Default 4. */
+    gap?: number;
+}
+interface ExportMenuPlacement {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+}
+/**
+ * Resolve menu placement, flipping to the opposite edge when the default
+ * position would overflow the chart container. Mirrors Highcharts'
+ * algorithm: horizontal flips freely; vertical only flips when the button
+ * is not top-aligned (top buttons have no room above to flip into).
+ */
+declare function resolveExportMenuPlacement(input: ExportMenuPlacementInput): ExportMenuPlacement;
+/**
+ * Get export action for menu item
+ */
+declare function getExportAction(item: Exclude<ExportMenuItem, 'separator'>): ExportItemAction;
+
+/**
+ * Build a drilldown tree from flat data with id/parent field accessors.
+ *
+ * Works for any chart type — the tree represents the drill hierarchy,
+ * not a specific visual layout.
+ *
+ * @param data - Flat array of data items
+ * @param idField - Field name for the node's unique ID
+ * @param parentField - Field name for the parent reference
+ * @param valueField - Field name for the numeric value (for aggregate computation)
+ */
+declare function buildDrilldownTree<T>(data: T[], idField: string, parentField: string, valueField: string): DrilldownTree<T>;
+/**
+ * Get direct children of a node. Returns root nodes if parentId is null.
+ */
+declare function getChildren<T>(tree: DrilldownTree<T>, parentId: string | null): DrilldownNode<T>[];
+/**
+ * Get the ancestor path from root to the given node (inclusive).
+ */
+declare function getAncestorPath<T>(tree: DrilldownTree<T>, nodeId: string, categoryField?: string): DrilldownBreadcrumb[];
+/**
+ * Check if a node has children (is drillable).
+ */
+declare function isParentNode<T>(tree: DrilldownTree<T>, nodeId: string): boolean;
+/**
+ * Get all leaf descendants of a node.
+ */
+declare function getLeaves<T>(node: DrilldownNode<T>): DrilldownNode<T>[];
+/**
+ * Create the initial drilldown state (at root level).
+ *
+ * @param rootLabel - Label for the root breadcrumb (e.g. "All", "S&P 500")
+ */
+declare function createDrilldownState(rootLabel?: string): DrilldownState;
+/**
+ * Drill into a node. Returns a new state with the node as current.
+ */
+declare function drillInto<T>(state: DrilldownState, tree: DrilldownTree<T>, nodeId: string, categoryField?: string): DrilldownState;
+/**
+ * Drill up one level. Returns a new state at the parent level.
+ */
+declare function drillUp(state: DrilldownState): DrilldownState;
+/**
+ * Drill to a specific level in the breadcrumb path.
+ */
+declare function drillToLevel(state: DrilldownState, index: number): DrilldownState;
+/**
+ * Drill back to root level.
+ */
+declare function drillToRoot(state: DrilldownState): DrilldownState;
+/**
+ * Returns true if any dataset in the map has drilldown explicitly enabled
+ * with the required hierarchy fields (nodeId + parent).
+ * Currently only treemap supports drilldown.
+ */
+declare function isDrilldownEnabled(datasets: Map<string, DatasetRegistration>): boolean;
+/**
+ * Returns the root breadcrumb label from the first drilldown-enabled treemap dataset.
+ * Falls back to 'All' if no explicit rootLabel is set.
+ */
+declare function getDrilldownRootLabel(datasets: Map<string, DatasetRegistration>): string;
+type TreemapLayoutProps = {
+    nodeId?: string;
+    parentField?: string;
+    data?: unknown[];
+    categoryField?: string;
+};
+/**
+ * Walk the flat data of the first treemap layout to build the ancestor path
+ * between `currentParentId` and `nodeId` (exclusive on both ends).
+ *
+ * Used by both React and Vue `useTreemapRenderer` when the user clicks into
+ * a nested node so the breadcrumb can be updated with any intermediate parents.
+ */
+declare function buildAncestorChain(nodeId: string, layouts: Map<string, {
+    props: TreemapLayoutProps;
+}>, currentParentId: string | null): {
+    id: string;
+    label: string;
+}[];
+
+/**
+ * Largest Triangle Three Buckets (LTTB) downsampling algorithm.
+ *
+ * For each bucket, selects the point forming the largest triangle area
+ * with the previously selected point and the average of the next bucket.
+ * Always preserves the first and last data points.
+ *
+ * Time complexity: O(n) single pass.
+ * Reference: Sveinn Steinarsson, "Downsampling Time Series for Visual Representation"
+ *
+ * @param yValues - Primary values array (Y coordinates)
+ * @param targetCount - Desired number of output points
+ * @param xValues - Optional X coordinates (defaults to indices 0..n-1 for equidistant data)
+ * @returns Array of indices into the original array to keep
+ */
+declare function decimateLTTB(yValues: readonly number[], targetCount: number, xValues?: readonly number[]): number[];
+/**
+ * Min-Max decimation algorithm.
+ *
+ * For each bucket, keeps both the minimum and maximum value points,
+ * preserving exact peaks and valleys. Returns up to 2 × targetCount
+ * indices (deduplicated), sorted in ascending order.
+ *
+ * Time complexity: O(n) single pass.
+ *
+ * @param yValues - Primary values array
+ * @param targetCount - Target number of buckets (output has up to 2× this many points)
+ * @returns Array of indices into the original array to keep, sorted ascending
+ */
+declare function decimateMinMax(yValues: readonly number[], targetCount: number): number[];
+/**
+ * Mini-batch k-means clustering for 2D scatter data.
+ *
+ * Unlike LTTB and min-max (which are 1D algorithms for ordered sequences),
+ * k-means preserves the 2D density distribution of scatter data by replacing
+ * clusters of nearby points with their centroid positions.
+ *
+ * Mini-batch variant: samples random batches per iteration for O(batchSize*k)
+ * per step instead of O(n*k), making it feasible for 100K+ point datasets.
+ *
+ * @param xValues - X coordinates
+ * @param yValues - Y coordinates
+ * @param targetCount - Number of output centroids (k)
+ * @returns Array of {x, y} centroid positions
+ */
+declare function decimateKMeans(xValues: readonly number[], yValues: readonly number[], targetCount: number): {
+    x: number;
+    y: number;
+}[];
+/**
+ * Decimate (downsample) a dataset using the configured algorithm.
+ *
+ * Short-circuits if the data length is at or below the threshold,
+ * returning all indices unchanged. Safe to call unconditionally
+ * in the pipeline without an outer length check.
+ *
+ * @param yValues - Primary values array (Y coordinates)
+ * @param config - Decimation configuration (algorithm, threshold, samples)
+ * @param xValues - Optional X coordinates (used by LTTB for non-equidistant data)
+ * @returns Array of original indices to keep
+ */
+declare function decimate(yValues: readonly number[], config: DecimationConfig, xValues?: readonly number[]): number[];
+/**
+ * Viewport-aware scatter decimation with k-means clustering.
+ *
+ * Stateful: maintains a cache keyed by original data reference to avoid
+ * k-means speckle from random centroid re-initialization on each call.
+ *
+ * Flow per dataset:
+ *   1. If data length <= threshold and no zoom, pass through unchanged
+ *   2. Viewport filter: keep only points in the visible zoom window
+ *   3. If filtered count <= samples, use filtered data (full detail on zoom-in)
+ *   4. Otherwise run k-means on the visible subset (cached by viewport key)
+ */
+declare class ScatterDecimator {
+    private cache;
+    /**
+     * Apply viewport-aware decimation to scatter datasets.
+     * Returns a new array with the same shape as `datasets`, with `props.data` replaced where decimated.
+     */
+    apply<T extends ScatterDecimationEntry>(datasets: readonly T[], config: ScatterDecimationConfig, zoomX?: ZoomRange | null, zoomY?: ZoomRange | null): T[];
+}
+
+export { resolveExportMenuProps as A, DEFAULT_EXPORT_MENU_ITEMS as D, EXPORT_MENU_CONSTANTS as E, HAMBURGER_ICON_PATH as H, ScatterDecimator as S, DEFAULT_EXPORT_MENU_PROPS as a, EXPORT_MENU_LABELS as b, type ExportMenuPlacement as c, type ExportMenuPlacementInput as d, buildAncestorChain as e, buildDrilldownTree as f, createDrilldownState as g, decimate as h, decimateKMeans as i, decimateLTTB as j, decimateMinMax as k, drillInto as l, drillToLevel as m, drillToRoot as n, drillUp as o, estimateExportMenuHeight as p, filterExportMenuItems as q, getAncestorPath as r, getChildren as s, getDrilldownRootLabel as t, getExportAction as u, getLeaves as v, isDrilldownEnabled as w, isExportMenuSeparator as x, isParentNode as y, resolveExportMenuPlacement as z };

package/dist/geometry-DUUQJXVM.d.mts

@@ -0,0 +1,60 @@
+import { ArcBoundingBox } from '@primeui/chart-types';
+
+/**
+ * Snap a coordinate to the nearest half-pixel boundary for crisp 1px lines.
+ *
+ * Both SVG and Canvas stroke centered on the coordinate — a 1px stroke at y=100
+ * paints from y=99.5 to y=100.5, spanning two rows and producing a blurry line.
+ * Snapping to y=100.5 makes the stroke fill exactly one pixel row (100–101).
+ *
+ * Only applies when strokeWidth is an odd integer. Even-width strokes already
+ * align to pixel boundaries without adjustment.
+ *
+ * @param value - The coordinate to snap
+ * @param strokeWidth - The line width (default: 1)
+ * @returns The snapped coordinate
+ */
+declare function crisp(value: number, strokeWidth?: number): number;
+/**
+ * Convert degrees to radians
+ */
+declare const toRad: (degrees: number) => number;
+/**
+ * Calculate x coordinate for given angle and radius
+ */
+declare const xCalc: (angle: number, radius: number) => number;
+/**
+ * Calculate y coordinate for given angle and radius
+ */
+declare const yCalc: (angle: number, radius: number) => number;
+/**
+ * Calculate a point on a circle given center, angle (degrees), and radius
+ */
+declare const pointOnCircle: (cx: number, cy: number, angle: number, radius: number) => {
+    x: number;
+    y: number;
+};
+/**
+ * Normalize an angle to the range [0, 360)
+ */
+declare const normalizeAngle: (angle: number) => number;
+/**
+ * Normalize an angle relative to a rotation baseline.
+ * Returns angle in range [rotation, rotation + 360)
+ *
+ * @param angle - The angle to normalize (degrees)
+ * @param rotation - The baseline rotation (degrees)
+ */
+declare const normalizeAngleRelativeTo: (angle: number, rotation: number) => number;
+/**
+ * Calculate the bounding box of an arc (partial pie/donut)
+ * @param cx - Center x coordinate
+ * @param cy - Center y coordinate
+ * @param radius - Radius of the arc
+ * @param startAngle - Start angle in degrees (rotation)
+ * @param sweepAngle - Sweep angle in degrees
+ * @returns Bounding box with minX, maxX, minY, maxY and center offset
+ */
+declare const calculateArcBoundingBox: (cx: number, cy: number, radius: number, startAngle: number, sweepAngle: number) => ArcBoundingBox;
+
+export { calculateArcBoundingBox as a, normalizeAngleRelativeTo as b, crisp as c, normalizeAngle as n, pointOnCircle as p, toRad as t, xCalc as x, yCalc as y };

package/dist/index-DseIZa1j.d.mts

@@ -0,0 +1,167 @@
+import { XAxisProps, YAxisProps, SeriesType, CartesianLayoutInput, HoverConfig, CartesianLayoutData, KeyboardNavState, DatasetRegistration, KeyboardNavigationConfig, DrilldownStateSnapshot, DrilldownBreadcrumb } from '@primeui/chart-types';
+import './series/bar/controller/index.mjs';
+import { C as ComputeChartStateInputs, a as ComputedChartState } from './computeChartState-BTVIqwyO.mjs';
+import './series/candlestick/controller/index.mjs';
+import './series/heatmap/controller/index.mjs';
+import './series/line/controller/index.mjs';
+import './series/pie/controller/index.mjs';
+import './series/polar/controller/index.mjs';
+import './series/radar/controller/index.mjs';
+import './series/scatter/controller/index.mjs';
+import './series/treemap/controller/index.mjs';
+
+interface AxisRegistrationControllerOptions {
+    id: string;
+    axis: 'x' | 'y';
+    registerX: (id: string, props: XAxisProps) => void;
+    unregisterX: (id: string) => void;
+    updateX: (id: string, props: XAxisProps) => void;
+    registerY: (id: string, props: YAxisProps) => void;
+    unregisterY: (id: string) => void;
+    updateY: (id: string, props: YAxisProps) => void;
+}
+declare class AxisRegistrationController {
+    private stableProps;
+    private readonly options;
+    constructor(options: AxisRegistrationControllerOptions);
+    mount(props: XAxisProps | YAxisProps): void;
+    update(props: XAxisProps | YAxisProps): void;
+    unmount(): void;
+    forceRefresh(props: XAxisProps | YAxisProps): void;
+}
+
+interface DatasetExtras {
+    stackId?: string;
+    rangeId?: string;
+    order?: number;
+}
+interface DatasetRegistrationControllerOptions<T extends Record<string, unknown>> {
+    id: string;
+    type: SeriesType;
+    typeResolver?: (props: T) => SeriesType;
+    register: (id: string, type: SeriesType, props: Record<string, unknown>) => void;
+    unregister: (id: string) => void;
+    update: (id: string, props: Record<string, unknown>) => void;
+}
+declare class DatasetRegistrationController<T extends Record<string, unknown>> {
+    private stableProps;
+    private prevType;
+    private readonly options;
+    constructor(options: DatasetRegistrationControllerOptions<T>);
+    mount(props: T, extras?: DatasetExtras): void;
+    update(props: T, extras?: DatasetExtras): void;
+    unmount(): void;
+    forceRefresh(props: T, extras?: DatasetExtras): void;
+    private resolveType;
+    private mergeProps;
+}
+
+type CartesianLayoutControllerInput = Omit<CartesianLayoutInput, 'hoverConfig'> & {
+    hoverConfig?: HoverConfig;
+};
+declare class CartesianLayoutController {
+    private _lastVisibleLayouts;
+    private _prevInputs;
+    private _prevResult;
+    /**
+     * Compute cartesian layout with built-in memoization.
+     * Skips recomputation when layout-affecting inputs are reference-equal to the
+     * previous call — `hover` is intentionally excluded so pointer movement
+     * does not trigger an expensive full layout pass.
+     */
+    compute(input: CartesianLayoutControllerInput): CartesianLayoutData | null;
+    destroy(): void;
+    private _inputsEqual;
+    private _inputsEqualExceptTheme;
+}
+
+interface ResponsiveDimensionsOptions {
+    debounceWithRAF?: boolean;
+    debounceDelay?: number;
+    aspectRatio?: number;
+    maxDimensions?: boolean;
+    maxWidth?: number;
+    maxHeight?: number;
+}
+declare class ResponsiveDimensionsController {
+    private _observer;
+    private _debouncer;
+    private _options;
+    /** Called with processed dimensions whenever the container resizes. */
+    onDimensionsChange: ((width: number, height: number) => void) | null;
+    /**
+     * Attach to a container element. Performs an initial synchronous measurement
+     * and begins observing resizes. Call detach() before re-attaching.
+     */
+    attach(containerEl: HTMLElement, options: ResponsiveDimensionsOptions): void;
+    detach(): void;
+    destroy(): void;
+    private _process;
+    private _emit;
+}
+
+declare class ChartStateController {
+    private _prevInputs;
+    private _prevResult;
+    /**
+     * Compute chart state with built-in memoization.
+     *  - Inputs reference-equal to the previous call → return the cached result.
+     *  - Only `theme` changed → reuse the cached (theme-independent) geometry and
+     *    recompute ONLY the theme-dependent style/legend fields (SPREAD-CLONE,
+     *    never mutating the cached result).
+     *  - Otherwise → full `computeChartState`.
+     */
+    compute(inputs: ComputeChartStateInputs): ComputedChartState;
+    destroy(): void;
+    private _inputsEqual;
+    private _inputsEqualExceptTheme;
+}
+
+declare class KeyboardNavigationController {
+    private _state;
+    private _lastFocusedIndexMap;
+    /** Called when navigation moves to a point. */
+    onNavigate: ((datasetId: string, index: number, announcement: string) => void) | null;
+    /** Called when navigation resets (mouse move, Escape, or disabled). */
+    onReset: (() => void) | null;
+    get state(): KeyboardNavState;
+    /**
+     * Process a keydown event. Returns true if the key was handled (caller should preventDefault).
+     */
+    handleKeyDown(key: string, datasets: Map<string, DatasetRegistration>, visibility: Map<string, boolean>, config?: KeyboardNavigationConfig): boolean;
+    /**
+     * Activate navigation from a focus event (keyboard Tab into the chart) rather than
+     * a key press, so the focus indicator + screen-reader announcement appear immediately
+     * on focus instead of waiting for the first arrow key. No-op when already active or
+     * there is nothing navigable. Navigates to the remembered point of the first dataset
+     * when `rememberPointFocus` is set, otherwise its first point. Fires `onNavigate`
+     * exactly like an arrow key.
+     *
+     * @returns true if navigation was activated.
+     */
+    activate(datasets: Map<string, DatasetRegistration>, visibility: Map<string, boolean>, config?: KeyboardNavigationConfig): boolean;
+    /** Call on mousemove — resets active keyboard nav. */
+    handleMouseMove(): void;
+    reset(): void;
+    destroy(): void;
+    private _applyAction;
+}
+
+declare class DrilldownStateController {
+    private snapshot;
+    private subscribers;
+    /** Stable getter — same reference until state actually changes (required for useSyncExternalStore). */
+    getSnapshot: () => DrilldownStateSnapshot;
+    subscribe: (fn: () => void) => (() => void);
+    /**
+     * Sync controller to the current dataset map. Called whenever datasets change.
+     * Recomputes `enabled` and the root breadcrumb label without touching the rest
+     * of the path.
+     */
+    setDatasets(datasets: Map<string, DatasetRegistration>): void;
+    drillInto: (nodeId: string, label: string, ancestors?: DrilldownBreadcrumb[]) => void;
+    drillToLevel: (index: number) => void;
+    private commit;
+}
+
+export { AxisRegistrationController as A, CartesianLayoutController as C, type DatasetExtras as D, KeyboardNavigationController as K, ResponsiveDimensionsController as R, type AxisRegistrationControllerOptions as a, type CartesianLayoutControllerInput as b, ChartStateController as c, DatasetRegistrationController as d, type DatasetRegistrationControllerOptions as e, DrilldownStateController as f, type ResponsiveDimensionsOptions as g };