@abdullahjaswal/tickyr-charts-solid 0.1.0

package/dist/charts/depth-chart-controller.d.ts

@@ -0,0 +1,84 @@
+import { Personalization, ThemeInput, VisualStyle, Theme, ResolvedMidLine, ResolvedLevelHighlight, SpreadDisplayMode, DepthFillType, PriceRangeWindow, ChartFormatter } from '../personalization';
+import { DepthSeries } from './depth-series';
+import { HoverState, DepthChartBaseProps, DepthChartTooltipProps } from './depth-chart-helpers';
+export interface DepthChartProviderSnapshot {
+    theme: ThemeInput;
+    palette: string;
+    locale: string;
+    timeZone: string | undefined;
+    visualStyle: VisualStyle;
+    outlineFillColor: "auto" | string;
+    outlineFillOpacity: number;
+    cornerRadius: number;
+    borderWidth: number;
+    accents: boolean;
+    osTheme: Theme;
+    appTheme: Theme;
+}
+export interface DepthChartRenderContext {
+    personalization: Personalization;
+    formatter: ChartFormatter;
+    resolvedLocaleBase: string;
+    resolvedTimeZone: string | undefined;
+    series: DepthSeries;
+    resolvedPriceWindow: {
+        min: number;
+        max: number;
+    };
+    resolvedPriceRange: PriceRangeWindow;
+    resolvedMidLine: ResolvedMidLine | null;
+    resolvedSpreadDisplay: SpreadDisplayMode;
+    resolvedFillType: DepthFillType;
+    resolvedLevelHighlight: ResolvedLevelHighlight | null;
+    cumulative: boolean;
+    ariaLabel: string;
+    cssWidth: number;
+    cssHeight: number;
+}
+export interface DepthChartControllerCallbacks {
+    onContextChange(ctx: DepthChartRenderContext): void;
+    onHoverChange(hover: HoverState | null): void;
+}
+export interface DepthChartControllerProps extends DepthChartBaseProps {
+    tooltip?: undefined | false | ((p: DepthChartTooltipProps) => unknown);
+}
+export interface DepthChartControllerMountOptions extends DepthChartControllerCallbacks {
+    container?: HTMLElement | null;
+    staticCanvas: HTMLCanvasElement;
+    dynamicCanvas: HTMLCanvasElement | null;
+    initialProps: DepthChartControllerProps;
+    initialProvider: DepthChartProviderSnapshot;
+}
+export declare class DepthChartController {
+    private staticCanvas;
+    private dynamicCanvas;
+    private callbacks;
+    private props;
+    private providerCtx;
+    private handle;
+    private hoverState;
+    private dynCfg;
+    private series;
+    private personalization;
+    private resolvedLocale;
+    private formatter;
+    private resolvedPriceRange;
+    private resolvedPriceWindow;
+    private resolvedMidLine;
+    private resolvedSpreadDisplay;
+    private resolvedFillType;
+    private resolvedLevelHighlight;
+    private cumulative;
+    private staticDrawAbort;
+    private disposed;
+    private visGate;
+    constructor(opts: DepthChartControllerMountOptions);
+    update(props: DepthChartControllerProps, providerCtx: DepthChartProviderSnapshot): void;
+    handlePointerMove(e: PointerEvent): void;
+    handlePointerLeave(): void;
+    dispose(): void;
+    private setHover;
+    private resolveDerived;
+    private applyDynamicCfgFromProps;
+    private runStaticDraw;
+}

package/dist/charts/depth-chart-helpers.d.ts

@@ -0,0 +1,185 @@
+import { Personalization, ThemeInput, DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat, LegendPosition, LegendVisibility, PriceRangeInput, MidLineInput, SpreadDisplayInput, DepthFillType, LevelHighlightInput, ResolvedMidLine, ResolvedLevelHighlight, ChartFormatter } from '../personalization';
+import { Viewport } from '../viewport/viewport-sizer';
+import { LinearScale } from '../viewport/scales/linear';
+import { NiceTick } from '../viewport/nice-ticks';
+import { YAxisPosition, XAxisPosition } from '../rendering/draw/axis';
+import { GridStyle } from '../rendering/draw/grid';
+import { CrosshairMarker } from '../rendering/draw/crosshair';
+import { DepthSeries } from './depth-series';
+export type { DepthLevel, DepthSeriesInput, } from './depth-series';
+export interface DepthChartTooltipProps {
+    /** Which side the cursor is over. */
+    readonly side: "bid" | "ask";
+    /** Price at the cursor's x. */
+    readonly price: number;
+    /** Cumulative volume at that price (the chart's y value). */
+    readonly cumulativeVolume: number;
+    /** Distance from the mid price as a fraction (e.g. -0.025 = 2.5% below mid). */
+    readonly pctFromMid: number;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: import('../personalization').Theme;
+    readonly palette: import('../personalization').Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+export interface DepthChartBaseProps {
+    /** Orderbook data - bids + asks parallel typed arrays. */
+    data?: import('./depth-series').DepthSeriesInput;
+    /** Default 'auto' (±5%). */
+    priceRange?: PriceRangeInput;
+    /** Default true (solid neutral line). */
+    midLine?: MidLineInput;
+    /** Default 'pill'. */
+    spreadDisplay?: SpreadDisplayInput;
+    /** Default true. */
+    cumulative?: boolean;
+    /** Default 'gradient'. */
+    fillType?: DepthFillType;
+    /** Default false. */
+    levelHighlight?: LevelHighlightInput;
+    /** Per-level data for `levelHighlight` - host-supplied. */
+    highlightLevels?: ReadonlyArray<{
+        readonly price: number;
+        readonly label?: string;
+    }>;
+    legend?: LegendVisibility;
+    legendPosition?: LegendPosition;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: import('../personalization/axes/glow').GlowInput;
+    glowColor?: import('../personalization/axes/glow').GlowColorInput;
+    /** Pattern fills. */
+    pattern?: import('../personalization/axes/pattern').PatternInput;
+    patternScale?: number;
+    patternColor?: import('../personalization/axes/pattern').PatternColorInput;
+    ariaLabel?: string;
+    axisVisible?: boolean;
+    yAxisPosition?: YAxisPosition;
+    xAxisPosition?: XAxisPosition;
+    yAxisPadding?: number;
+    gridVisible?: boolean;
+    gridStyle?: GridStyle;
+    gridDensity?: "sparse" | "normal" | "dense";
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+export declare const DEFAULT_FONT = "12px system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif";
+export declare const DEFAULT_AXIS_FONT_SIZE = 11;
+export declare const LABEL_GAP_PX = 6;
+export declare const TICK_LENGTH_PX = 4;
+export declare const Y_AXIS_RESERVE_PX = 80;
+export declare const X_AXIS_RESERVE_PX = 28;
+export declare const GRID_TARGET: {
+    readonly sparse: 4;
+    readonly normal: 8;
+    readonly dense: 12;
+};
+export interface HoverState {
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly snapX: number;
+    readonly snapY: number;
+    readonly side: "bid" | "ask";
+    readonly price: number;
+    readonly cumulativeVolume: number;
+    readonly pctFromMid: number;
+}
+export interface DynamicCfg {
+    readonly crosshairVisible: boolean;
+    readonly crosshairLineStyle: GridStyle;
+    readonly crosshairMarker: CrosshairMarker;
+}
+export interface ChartLayout {
+    innerLeft: number;
+    innerRight: number;
+    innerTop: number;
+    innerBottom: number;
+    /** Maps a price to an x-pixel. */
+    xScale: LinearScale;
+    /** Maps a cumulative volume to a y-pixel. */
+    yScale: LinearScale;
+    xTicks: readonly NiceTick[];
+    yTicks: readonly NiceTick[];
+    /** Visible price window. */
+    priceMin: number;
+    priceMax: number;
+    /** Mid price (NaN if data is empty). */
+    midPrice: number;
+    viewport: Viewport;
+}
+export interface ChartHandle {
+    readonly dynamicCtx: CanvasRenderingContext2D | null;
+    readonly layout: ChartLayout;
+    readonly crosshairLineColor: string;
+    readonly crosshairMarkerFill: string;
+    readonly crosshairMarkerStroke: string;
+    readonly bidColor: string;
+    readonly askColor: string;
+}
+export declare function computeLayout(opts: {
+    series: DepthSeries;
+    priceWindow: {
+        min: number;
+        max: number;
+    };
+    viewport: Viewport;
+    yAxisPosition: YAxisPosition;
+    xAxisPosition: XAxisPosition;
+    yAxisPadding: number;
+    gridDensity: "sparse" | "normal" | "dense";
+    axisVisible: boolean;
+    formatter: ChartFormatter;
+}): ChartLayout;
+export declare function defaultAriaLabel(series: DepthSeries): string;
+export interface DrawFullDepthArgs {
+    ctx: CanvasRenderingContext2D;
+    series: DepthSeries;
+    personalization: Personalization;
+    accents: boolean;
+    layout: ChartLayout;
+    axisVisible: boolean;
+    gridVisible: boolean;
+    gridStyle: GridStyle;
+    yAxisPosition: YAxisPosition;
+    xAxisPosition: XAxisPosition;
+    cumulative: boolean;
+    fillType: DepthFillType;
+    midLine: ResolvedMidLine | null;
+    spreadDisplay: "off" | "pill" | "inline";
+    levelHighlight: ResolvedLevelHighlight | null;
+    highlightLevels: ReadonlyArray<{
+        price: number;
+        label?: string;
+    }>;
+    formatter: ChartFormatter;
+}
+export declare function drawFullDepthChart(args: DrawFullDepthArgs): void;
+export declare function drawDepthDynamicLayer(handle: ChartHandle, hover: HoverState | null, cfg: DynamicCfg): void;
+export declare function findCumulativeAtPrice(prices: Float64Array, cumulative: Float64Array, n: number, price: number, side: "bid" | "ask"): {
+    idx: number;
+    cumulative: number;
+} | null;

package/dist/charts/depth-series.d.ts

@@ -0,0 +1,41 @@
+export interface DepthLevel {
+    readonly price: number;
+    readonly size: number;
+}
+export interface DepthSeriesInput {
+    readonly bids: readonly DepthLevel[] | {
+        readonly prices: Float64Array;
+        readonly sizes: Float64Array;
+    };
+    readonly asks: readonly DepthLevel[] | {
+        readonly prices: Float64Array;
+        readonly sizes: Float64Array;
+    };
+}
+export declare class DepthSeries {
+    #private;
+    readonly bidPrices: Float64Array;
+    readonly bidSizes: Float64Array;
+    readonly bidCumulative: Float64Array;
+    readonly askPrices: Float64Array;
+    readonly askSizes: Float64Array;
+    readonly askCumulative: Float64Array;
+    readonly bestBid: number;
+    readonly bestAsk: number;
+    readonly midPrice: number;
+    readonly spread: number;
+    constructor(bidPrices: Float64Array, bidSizes: Float64Array, bidCumulative: Float64Array, askPrices: Float64Array, askSizes: Float64Array, askCumulative: Float64Array);
+    get revisionId(): number;
+    bumpRevision(): number;
+}
+export declare function ingestDepthSeries(input: DepthSeriesInput): DepthSeries;
+/** In-order running sum: `out[i] = Σ sizes[0..i]`. Caller-owned buffer. */
+export declare function computeCumulative(sizes: Float64Array, n: number, out: Float64Array): void;
+/** Compute the visible price window from a mid price + percentage range. */
+export declare function visiblePriceWindow(midPrice: number, range: {
+    readonly minPct: number;
+    readonly maxPct: number;
+}): {
+    min: number;
+    max: number;
+};

package/dist/charts/heatmap-chart-controller.d.ts

@@ -0,0 +1,78 @@
+import { Personalization, ThemeInput, VisualStyle, Theme, ResolvedHeatmapColorScale, CellShape, NullBehavior, AxisLabelsMode, ChartFormatter } from '../personalization';
+import { HoverState, HeatmapChartBaseProps, HeatmapChartTooltipProps, HeatmapMatrix } from './heatmap-chart-helpers';
+import { ResolvedHeatmapDomain } from './heatmap-color-compute';
+export interface HeatmapChartProviderSnapshot {
+    theme: ThemeInput;
+    palette: string;
+    locale: string;
+    timeZone: string | undefined;
+    visualStyle: VisualStyle;
+    outlineFillColor: "auto" | string;
+    outlineFillOpacity: number;
+    cornerRadius: number;
+    borderWidth: number;
+    accents: boolean;
+    osTheme: Theme;
+    appTheme: Theme;
+}
+export interface HeatmapChartRenderContext {
+    personalization: Personalization;
+    formatter: ChartFormatter;
+    resolvedLocaleBase: string;
+    resolvedTimeZone: string | undefined;
+    matrix: HeatmapMatrix;
+    resolvedColorScale: ResolvedHeatmapColorScale;
+    resolvedDomain: ResolvedHeatmapDomain;
+    cellShape: CellShape;
+    nullBehavior: NullBehavior;
+    axisLabels: AxisLabelsMode;
+    ariaLabel: string;
+    cssWidth: number;
+    cssHeight: number;
+}
+export interface HeatmapChartControllerCallbacks {
+    onContextChange(ctx: HeatmapChartRenderContext): void;
+    onHoverChange(hover: HoverState | null): void;
+}
+export interface HeatmapChartControllerProps extends HeatmapChartBaseProps {
+    tooltip?: undefined | false | ((p: HeatmapChartTooltipProps) => unknown);
+}
+export interface HeatmapChartControllerMountOptions extends HeatmapChartControllerCallbacks {
+    container?: HTMLElement | null;
+    staticCanvas: HTMLCanvasElement;
+    dynamicCanvas: HTMLCanvasElement | null;
+    initialProps: HeatmapChartControllerProps;
+    initialProvider: HeatmapChartProviderSnapshot;
+}
+export declare class HeatmapChartController {
+    private staticCanvas;
+    private dynamicCanvas;
+    private callbacks;
+    private props;
+    private providerCtx;
+    private handle;
+    private hoverState;
+    private dynCfg;
+    private matrix;
+    private personalization;
+    private resolvedLocale;
+    private formatter;
+    private resolvedColorScale;
+    private resolvedDomain;
+    private cellShape;
+    private nullBehavior;
+    private axisLabels;
+    private cellColors;
+    private staticDrawAbort;
+    private disposed;
+    private visGate;
+    constructor(opts: HeatmapChartControllerMountOptions);
+    update(props: HeatmapChartControllerProps, providerCtx: HeatmapChartProviderSnapshot): void;
+    handlePointerMove(e: PointerEvent): void;
+    handlePointerLeave(): void;
+    dispose(): void;
+    private setHover;
+    private resolveDerived;
+    private applyDynamicCfgFromProps;
+    private runStaticDraw;
+}

package/dist/charts/heatmap-chart-helpers.d.ts

@@ -0,0 +1,174 @@
+import { Personalization, ThemeInput, DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat, LegendPosition, LegendVisibility, HeatmapColorScaleInput, CellShape, NullBehavior, AxisLabelsMode, ChartFormatter } from '../personalization';
+import { Viewport } from '../viewport/viewport-sizer';
+import { GridStyle } from '../rendering/draw/grid';
+import { CrosshairMarker } from '../rendering/draw/crosshair';
+import { ResolvedHeatmapDomain } from './heatmap-color-compute';
+export interface HeatmapMatrixInput {
+    /** Number of rows (y-axis cells). */
+    readonly rows: number;
+    /** Number of columns (x-axis cells). */
+    readonly cols: number;
+    /** Cell values, row-major (`values[r * cols + c]`). Length = rows × cols. */
+    readonly values: Float64Array | readonly number[];
+    /** Optional per-row labels (length = rows). When omitted, row indices. */
+    readonly rowLabels?: readonly string[];
+    /** Optional per-column labels (length = cols). When omitted, column indices. */
+    readonly colLabels?: readonly string[];
+    /** Optional null mask, row-major (`1` = null cell, `0` = value). */
+    readonly nullMask?: Uint8Array | readonly number[];
+}
+export declare class HeatmapMatrix {
+    #private;
+    readonly rows: number;
+    readonly cols: number;
+    readonly values: Float64Array;
+    readonly rowLabels: readonly string[] | null;
+    readonly colLabels: readonly string[] | null;
+    readonly nullMask: Uint8Array | null;
+    readonly length: number;
+    constructor(rows: number, cols: number, values: Float64Array, rowLabels: readonly string[] | null, colLabels: readonly string[] | null, nullMask: Uint8Array | null);
+    get revisionId(): number;
+    bumpRevision(): number;
+}
+export declare function ingestHeatmapMatrix(input: HeatmapMatrixInput): HeatmapMatrix;
+export interface HeatmapChartTooltipProps {
+    readonly row: number;
+    readonly col: number;
+    readonly value: number | null;
+    readonly rowLabel: string;
+    readonly colLabel: string;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: import('../personalization').Theme;
+    readonly palette: import('../personalization').Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+export interface HeatmapChartBaseProps {
+    /** Row-major matrix of values to color. See `HeatmapMatrixInput`
+     *  for the row labels / col labels / values shape. */
+    data?: HeatmapMatrixInput;
+    /** Default 'diverging'. */
+    colorScale?: HeatmapColorScaleInput;
+    /** Default 2 px (gapUnit). */
+    cellPadding?: number;
+    /** Default 'rect'. */
+    cellShape?: CellShape;
+    /** Default false. true = auto-contrast text per cell. */
+    valueDisplay?: boolean;
+    /** Default 'both'. */
+    axisLabels?: AxisLabelsMode;
+    /** Default 'cross-hatch'. */
+    nullBehavior?: NullBehavior;
+    legend?: LegendVisibility;
+    legendPosition?: LegendPosition;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: import('../personalization/axes/glow').GlowInput;
+    glowColor?: import('../personalization/axes/glow').GlowColorInput;
+    /** Pattern fills. */
+    pattern?: import('../personalization/axes/pattern').PatternInput;
+    patternScale?: number;
+    patternColor?: import('../personalization/axes/pattern').PatternColorInput;
+    ariaLabel?: string;
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    cornerRadius?: number;
+    borderWidth?: number;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+export declare const DEFAULT_FONT = "12px system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif";
+export declare const DEFAULT_AXIS_FONT_SIZE = 11;
+export declare const DEFAULT_CELL_PADDING_PX = 2;
+export declare const DEFAULT_VALUE_FONT_SIZE = 10;
+export declare const ROW_LABEL_RESERVE_PX = 64;
+export declare const COL_LABEL_RESERVE_PX = 24;
+export declare const VALUE_LABEL_MIN_CELL_PX = 28;
+export interface HoverState {
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly snapX: number;
+    readonly snapY: number;
+    readonly row: number;
+    readonly col: number;
+    readonly value: number | null;
+    readonly rowLabel: string;
+    readonly colLabel: string;
+}
+export interface DynamicCfg {
+    readonly crosshairVisible: boolean;
+    readonly crosshairLineStyle: GridStyle;
+    readonly crosshairMarker: CrosshairMarker;
+}
+export interface ChartLayout {
+    innerLeft: number;
+    innerRight: number;
+    innerTop: number;
+    innerBottom: number;
+    cellWidthPx: number;
+    cellHeightPx: number;
+    rows: number;
+    cols: number;
+    viewport: Viewport;
+}
+export interface ChartHandle {
+    readonly dynamicCtx: CanvasRenderingContext2D | null;
+    readonly layout: ChartLayout;
+    readonly crosshairLineColor: string;
+    readonly crosshairMarkerFill: string;
+    readonly crosshairMarkerStroke: string;
+}
+export declare function computeLayout(opts: {
+    matrix: HeatmapMatrix;
+    viewport: Viewport;
+    axisLabels: AxisLabelsMode;
+}): ChartLayout;
+export declare function defaultAriaLabel(matrix: HeatmapMatrix): string;
+export interface DrawFullHeatmapArgs {
+    ctx: CanvasRenderingContext2D;
+    matrix: HeatmapMatrix;
+    /** Pre-computed CSS color per cell (length = rows × cols). Empty string =
+     *  null sentinel, drawn per `nullBehavior`. */
+    cellColors: readonly string[];
+    personalization: Personalization;
+    layout: ChartLayout;
+    cellShape: CellShape;
+    cellPadding: number;
+    cornerRadius: number;
+    borderWidth: number;
+    axisLabels: AxisLabelsMode;
+    valueDisplay: boolean;
+    nullBehavior: NullBehavior;
+    /** Resolved domain - for value-label numeric formatting. */
+    domain: ResolvedHeatmapDomain;
+    formatter: ChartFormatter;
+    accents: boolean;
+}
+export declare function drawFullHeatmapChart(args: DrawFullHeatmapArgs): void;
+export declare function drawHeatmapDynamicLayer(handle: ChartHandle, hover: HoverState | null, cfg: DynamicCfg): void;
+export declare function findCellAt(layout: ChartLayout, px: number, py: number): {
+    row: number;
+    col: number;
+} | null;

package/dist/charts/heatmap-color-compute.d.ts

@@ -0,0 +1,11 @@
+import { PaletteVariant } from '../personalization/palette/types';
+import { ResolvedHeatmapColorScale } from '../personalization/axes/heatmap-color-scale';
+export interface ResolvedHeatmapDomain {
+    readonly min: number;
+    readonly max: number;
+    readonly midpoint: number;
+}
+export declare function computeHeatmapDomain(values: Float64Array, n: number, nullMask: Uint8Array | null, scale: ResolvedHeatmapColorScale): ResolvedHeatmapDomain;
+/** Build per-cell CSS color strings into the caller-owned `out` array.
+ *  `out.length` must equal `n`. */
+export declare function buildHeatmapColors(values: Float64Array, n: number, nullMask: Uint8Array | null, scale: ResolvedHeatmapColorScale, domain: ResolvedHeatmapDomain, variant: PaletteVariant, out: string[]): void;

package/dist/charts/hierarchy.d.ts

@@ -0,0 +1,49 @@
+export interface HierarchyNode {
+    readonly name: string;
+    /** Optional explicit value. Internal-node values are always overridden
+     *  by the sum of leaf-descendant values (treemap layout invariant). */
+    readonly value?: number;
+    /** Optional CSS color override; auto-cycle through palette.categorical. */
+    readonly color?: string;
+    /** Optional signed percent change (e.g. `-2.2`,
+     *  `1.7`). When supplied, drives the `'directional'` color scale + the
+     *  `'ticker'` label preset (▲/▼ glyph + magnitude). Internal-node deltas
+     *  are computed at ingest time as the value-weighted average of leaf
+     *  descendants. */
+    readonly delta?: number;
+    /** Optional secondary line rendered below the name in 'ticker' label
+     *  layout (e.g. company name beneath the symbol). */
+    readonly sublabel?: string;
+    readonly children?: readonly HierarchyNode[];
+}
+export interface Hierarchy {
+    readonly names: readonly string[];
+    /** Per-node aggregate value. Internal nodes carry the sum of leaf descendants. */
+    readonly values: Float64Array;
+    /** Per-node signed delta percent. NaN sentinel = no delta available. */
+    readonly deltas: Float64Array;
+    /** Optional secondary line per node ('' when absent). */
+    readonly sublabels: readonly string[];
+    /** Tree depth (root = 0). */
+    readonly depths: Int32Array;
+    /** Parent node id (-1 for root). */
+    readonly parents: Int32Array;
+    /** First child id (-1 if leaf). */
+    readonly firstChildIdx: Int32Array;
+    /** Number of immediate children. */
+    readonly childCount: Int32Array;
+    /** Subtree size (1 = leaf, 1 + sum of children's subtreeSize for internal). */
+    readonly subtreeSize: Int32Array;
+    /** Per-node color overrides; null = auto-cycle palette.categorical. */
+    readonly colorOverrides: readonly (string | null)[];
+    readonly length: number;
+}
+export declare function ingestHierarchy(root: HierarchyNode): Hierarchy;
+export declare function totalDescendantValue(h: Hierarchy, idx: number): number;
+/** Resolve a path of names to its node index. `[]` returns the root.
+ *  Returns -1 if any segment doesn't exist. */
+export declare function descendantsOfPath(h: Hierarchy, path: readonly string[]): number;
+/** Iterate immediate children of `parentIdx`. Calls `visitor(childIdx)` for each. */
+export declare function forEachChild(h: Hierarchy, parentIdx: number, visitor: (childIdx: number) => void): void;
+/** Iterate every descendant of `rootIdx` (inclusive), in DFS pre-order. */
+export declare function forEachDescendant(h: Hierarchy, rootIdx: number, visitor: (idx: number, relativeDepth: number) => void): void;

package/dist/charts/histogram-binning.d.ts

@@ -0,0 +1,33 @@
+import { BinAlgorithm } from '../personalization/axes/bin-algorithm';
+import { YAxisMode } from '../personalization/axes/y-axis-mode';
+export interface BinRange {
+    readonly min: number;
+    readonly max: number;
+}
+export interface NormalFit {
+    readonly mean: number;
+    readonly std: number;
+}
+export declare function computeRange(values: Float64Array, n: number): BinRange;
+/** Choose a bin count via the locked algorithm. Caller picks `binStart`/
+ *  `binEnd` separately; this only decides `count`. */
+export declare function chooseBinCount(values: Float64Array, n: number, algo: BinAlgorithm, fixedCount?: number): number;
+/** Bin `values[0..n-1]` into `binCount` equal-width bins spanning
+ *  `[binStart, binEnd]`. Writes:
+ *    - `outEdges[binCount + 1]`: edge values (start, intermediate, end)
+ *    - `outCounts[binCount]`: per-bin count
+ *  Points outside the range are skipped; points exactly at `binEnd` clamp
+ *  into the last bin. */
+export declare function computeBins(values: Float64Array, n: number, binStart: number, binEnd: number, binCount: number, outEdges: Float64Array, outCounts: Uint32Array): void;
+/** Map raw counts to the y-axis mode the host requested.
+ *    - 'frequency'  → `out[i] = counts[i]`
+ *    - 'density'    → `out[i] = counts[i] / (n × binWidth)` so area sums to 1
+ *    - 'cumulative' → `out[i] = Σ counts[0..i]` */
+export declare function applyYAxisMode(counts: Uint32Array, mode: YAxisMode, binWidth: number, totalCount: number, out: Float64Array): void;
+/** Fit a normal distribution `N(μ, σ)` for the 'normal' overlay.
+ *  Two-pass mean + variance (numerically stable enough for our scale -
+ *  histograms are summary visuals, not financial-grade math; engine owns
+ *  Welford-precision compute paths). */
+export declare function fitNormalOverlay(values: Float64Array, n: number): NormalFit;
+/** Evaluate `N(mean, std)` PDF at `x`. Returns 0 when std === 0. */
+export declare function normalPdf(x: number, mean: number, std: number): number;