@abdullahjaswal/tickyr-charts-solid 0.1.0

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

@@ -0,0 +1,107 @@
+import { Personalization, ThemeInput, VisualStyle, Theme, LabelBehavior, TreemapColorScale, ViewMode, RadiusProportion, LabelRotation, ResolvedLabelContent, ChartFormatter } from '../personalization';
+import { Hierarchy } from './hierarchy';
+import { HoverState, SunburstChartBaseProps, SunburstChartTooltipProps } from './sunburst-chart-helpers';
+export interface SunburstChartProviderSnapshot {
+    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 SunburstChartRenderContext {
+    personalization: Personalization;
+    formatter: ChartFormatter;
+    resolvedLocaleBase: string;
+    resolvedTimeZone: string | undefined;
+    hierarchy: Hierarchy;
+    currentPath: readonly string[];
+    rootIdx: number;
+    resolvedLabelBehavior: LabelBehavior;
+    resolvedColorScale: TreemapColorScale;
+    resolvedViewMode: ViewMode;
+    resolvedRadiusProportion: RadiusProportion;
+    resolvedLabelRotation: LabelRotation;
+    resolvedLabelContent: ResolvedLabelContent;
+    showBreadcrumb: boolean;
+    totalValue: number;
+    ariaLabel: string;
+    cssWidth: number;
+    cssHeight: number;
+    /** True when drilled in (rootIdx is not the topmost hierarchy node).
+     *  Hosts use this to render the center back-button overlay. */
+    isDrilled: boolean;
+    /** Diameter of the center disc reserved for the back-button overlay
+     *  when `isDrilled` is true. 0 when nested. */
+    centerDiscDiameter: number;
+    /** Name of the currently-drilled-into node (= the visible root). */
+    rootName: string;
+    /** Aggregated value of the currently-drilled-into root. */
+    rootValue: number;
+    /** Aggregated delta of the currently-drilled-into root (NaN when none). */
+    rootDelta: number;
+}
+export interface SunburstChartControllerCallbacks {
+    onContextChange(ctx: SunburstChartRenderContext): void;
+    onHoverChange(hover: HoverState | null): void;
+}
+export interface SunburstChartControllerProps extends SunburstChartBaseProps {
+    tooltip?: undefined | false | ((p: SunburstChartTooltipProps) => unknown);
+}
+export interface SunburstChartControllerMountOptions extends SunburstChartControllerCallbacks {
+    container?: HTMLElement | null;
+    staticCanvas: HTMLCanvasElement;
+    dynamicCanvas: HTMLCanvasElement | null;
+    initialProps: SunburstChartControllerProps;
+    initialProvider: SunburstChartProviderSnapshot;
+}
+export declare class SunburstChartController {
+    private staticCanvas;
+    private dynamicCanvas;
+    private callbacks;
+    private props;
+    private providerCtx;
+    private handle;
+    private hoverState;
+    private dynCfg;
+    private hierarchy;
+    private personalization;
+    private resolvedLocale;
+    private formatter;
+    private resolvedLabelBehavior;
+    private resolvedColorScale;
+    private resolvedViewMode;
+    private resolvedRadiusProportion;
+    private resolvedLabelRotation;
+    private resolvedLabelContent;
+    private resolvedDepthLimit;
+    private internalPath;
+    private currentPath;
+    private rootIdx;
+    private nodeColors;
+    private a0Buf;
+    private a1Buf;
+    private r0Buf;
+    private r1Buf;
+    private staticDrawAbort;
+    private disposed;
+    private visGate;
+    constructor(opts: SunburstChartControllerMountOptions);
+    update(props: SunburstChartControllerProps, providerCtx: SunburstChartProviderSnapshot): void;
+    handlePointerMove(e: PointerEvent): void;
+    handlePointerLeave(): void;
+    drillTo(idx: number): void;
+    handleClick(e: MouseEvent): void;
+    setPath(newPath: readonly string[]): void;
+    dispose(): void;
+    private setHover;
+    private resolveDerived;
+    private applyDynamicCfgFromProps;
+    private runStaticDraw;
+}

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

@@ -0,0 +1,143 @@
+import { Personalization, ThemeInput, DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat, LegendPosition, LegendVisibility, LabelBehavior, DepthLimitInput, TreemapColorScale, ViewMode, RadiusProportion, LabelRotation, LabelContentInput, ResolvedLabelContent, ChartFormatter } from '../personalization';
+import { Viewport } from '../viewport/viewport-sizer';
+import { GridStyle } from '../rendering/draw/grid';
+import { CrosshairMarker } from '../rendering/draw/crosshair';
+import { Hierarchy, HierarchyNode } from './hierarchy';
+import { resolveTreemapColors } from './treemap-chart-helpers';
+export type { HierarchyNode };
+export interface SunburstChartTooltipProps {
+    readonly idx: number;
+    readonly name: string;
+    readonly value: number;
+    readonly percent: number;
+    readonly depth: number;
+    readonly path: readonly string[];
+    readonly color: 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 SunburstChartBaseProps {
+    /** Root hierarchy - a tree of `{ name, value?, children? }`. The
+     *  chart renders concentric rings, one per depth level. */
+    data?: HierarchyNode;
+    /** Default 'uniform'. */
+    radiusProportion?: RadiusProportion;
+    /** Default 'horizontal'. */
+    labelRotation?: LabelRotation;
+    /** Default false. Same shape as DonutChart's centerLabel. */
+    centerLabel?: boolean | string;
+    /** Inherited from PieChart-related axes - gap between slices. Default 1°. */
+    padAngle?: number;
+    /** Inherited from TreemapChart axes. */
+    labelBehavior?: LabelBehavior;
+    labelContent?: LabelContentInput;
+    depthLimit?: DepthLimitInput;
+    colorScale?: TreemapColorScale;
+    viewMode?: ViewMode;
+    breadcrumb?: boolean;
+    currentPath?: readonly string[];
+    onPathChange?: (path: readonly string[]) => void;
+    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_SUNBURST_PAD_ANGLE_DEG = 1.5;
+export declare const DEFAULT_FONT = "11px system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif";
+export interface HoverState {
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly idx: number;
+    readonly name: string;
+    readonly value: number;
+    readonly percent: number;
+    readonly depth: number;
+    readonly path: readonly string[];
+    readonly color: string;
+}
+export interface DynamicCfg {
+    readonly crosshairVisible: boolean;
+    readonly crosshairLineStyle: GridStyle;
+    readonly crosshairMarker: CrosshairMarker;
+}
+export interface ChartLayout {
+    innerLeft: number;
+    innerRight: number;
+    innerTop: number;
+    innerBottom: number;
+    cx: number;
+    cy: number;
+    maxRadius: number;
+    /** Per-node geometry. */
+    a0: Float64Array;
+    a1: Float64Array;
+    r0: Float64Array;
+    r1: Float64Array;
+    rootIdx: number;
+    maxRelativeDepth: number;
+    viewport: Viewport;
+}
+export interface ChartHandle {
+    readonly dynamicCtx: CanvasRenderingContext2D | null;
+    readonly layout: ChartLayout;
+    readonly crosshairLineColor: string;
+    readonly crosshairMarkerStroke: string;
+    readonly nodeColors: readonly string[];
+}
+export declare function defaultAriaLabel(h: Hierarchy): string;
+export declare function pathTo(h: Hierarchy, idx: number): readonly string[];
+export { resolveTreemapColors };
+export interface DrawFullSunburstArgs {
+    ctx: CanvasRenderingContext2D;
+    h: Hierarchy;
+    layout: ChartLayout;
+    nodeColors: readonly string[];
+    personalization: Personalization;
+    borderWidth: number;
+    labelRotation: LabelRotation;
+    resolvedLabelContent: ResolvedLabelContent;
+    formatter: ChartFormatter;
+    totalValue: number;
+    viewMode?: ViewMode;
+}
+export declare function drawFullSunburstChart(args: DrawFullSunburstArgs): void;
+export declare function drawSunburstDynamicLayer(handle: ChartHandle, hover: HoverState | null, cfg: DynamicCfg): void;
+export declare function findSliceAtRadial(h: Hierarchy, layout: ChartLayout, px: number, py: number): number;

package/dist/charts/sunburst-layout.d.ts

@@ -0,0 +1,40 @@
+import { RadiusProportion } from '../personalization/axes/radius-proportion';
+import { Hierarchy } from './hierarchy';
+export interface SunburstLayoutOptions {
+    /** Starting angle in radians (root spans [startAngle, endAngle]). */
+    readonly startAngle: number;
+    readonly endAngle: number;
+    /** Outer radius in pixels (root center = 0). */
+    readonly maxRadius: number;
+    /** Gap between sibling slices (radians). */
+    readonly padAngle: number;
+    /** Radial gap (px) BETWEEN concentric rings. The innermost visible
+     *  ring's inner edge and the outermost ring's outer edge are left
+     *  untouched - only the boundaries between rings get the inset. */
+    readonly ringGap?: number;
+    /** Ring-thickness allocation. */
+    readonly radiusProportion: RadiusProportion;
+    /** Maximum depth to render - interpreted as ABSOLUTE depth in the
+     *  hierarchy. For nested mode (rootIdx === 0) this is identical to
+     *  the relative depth from root. For drill-down (rootIdx > 0) the
+     *  layout converts to relative via `maxDepth - depths[rootIdx]`. */
+    readonly maxDepth: number;
+    /** Which node is the visible root. Default 0 - the hierarchy root.
+     *  When non-zero, the layout re-roots so children of `rootIdx` fill
+     *  the entire angular range and the entire `[innerRadius, maxRadius]`
+     *  radial range. */
+    readonly rootIdx?: number;
+    /** Center-disc radius (px) when re-rooted. The visible root takes
+     *  `[0, innerRadius]` - typically used by hosts to reserve room for a
+     *  back-button / drilled-parent label overlay. Default 0. */
+    readonly innerRadius?: number;
+}
+/** Lay out the entire hierarchy into the caller-owned arrays. Each must
+ *  have length === h.length. */
+export declare function layoutSunburst(h: Hierarchy, opts: SunburstLayoutOptions, a0: Float64Array, a1: Float64Array, r0: Float64Array, r1: Float64Array): void;
+/** Equal-thickness rings. */
+export declare function ringRadiiUniform(start: number, end: number, depth: number): readonly number[];
+/** Ring thickness proportional to the total value at each depth level. */
+export declare function ringRadiiValueWeighted(h: Hierarchy, start: number, end: number, depth: number): readonly number[];
+/** Square-root-scaled compromise. */
+export declare function ringRadiiSqrtWeighted(h: Hierarchy, start: number, end: number, depth: number): readonly number[];

package/dist/charts/time-off-algorithms.d.ts

@@ -0,0 +1,53 @@
+import { ResolvedBoxSizing } from '../personalization/axes/box-sizing';
+interface CandleSeriesView {
+    readonly times: Float64Array;
+    readonly opens: Float64Array;
+    readonly highs: Float64Array;
+    readonly lows: Float64Array;
+    readonly closes: Float64Array;
+}
+export declare function computeAtrApprox(c: CandleSeriesView, period: number): number;
+export declare function resolveBoxValue(c: CandleSeriesView, sizing: ResolvedBoxSizing): number;
+export interface RenkoBricks {
+    /** Each brick's bottom price. */
+    readonly bottomPrices: Float64Array;
+    /** Each brick's top price (always bottomPrices[i] + brickSize). */
+    readonly topPrices: Float64Array;
+    /** +1 for up brick, -1 for down brick. */
+    readonly directions: Int8Array;
+    /** Source candle index that printed this brick. Useful for tooltips. */
+    readonly sourceIdx: Int32Array;
+    readonly length: number;
+    readonly brickSize: number;
+}
+export type RenkoSource = "close" | "high-low";
+export declare function buildRenkoBricks(c: CandleSeriesView, brickSize: number, reversalThreshold: number, source: RenkoSource): RenkoBricks;
+export interface KagiLegs {
+    /** Start price of each leg. */
+    readonly startPrices: Float64Array;
+    /** End price of each leg. */
+    readonly endPrices: Float64Array;
+    /** +1 for up leg, -1 for down leg. */
+    readonly directions: Int8Array;
+    /** Whether this leg renders as Yang (thick / true) or Yin (thin / false).
+     *  Resolved at draw time per `thicknessRule`. */
+    readonly thick: Uint8Array;
+    /** Source candle index where the leg ended. */
+    readonly sourceIdx: Int32Array;
+    readonly length: number;
+}
+export declare function buildKagiLegs(c: CandleSeriesView, reversalAmount: number, source: RenkoSource): KagiLegs;
+export interface PnFColumns {
+    /** Each column's bottom-most box price. */
+    readonly bottomBoxes: Float64Array;
+    /** Each column's top-most box price. */
+    readonly topBoxes: Float64Array;
+    /** +1 for X (up) column, -1 for O (down) column. */
+    readonly directions: Int8Array;
+    /** Source candle index where this column ended. */
+    readonly sourceIdx: Int32Array;
+    readonly length: number;
+    readonly boxSize: number;
+}
+export declare function buildPnFColumns(c: CandleSeriesView, boxSize: number, reversalCount: number, source: RenkoSource): PnFColumns;
+export {};

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

@@ -0,0 +1,103 @@
+import { Personalization, ThemeInput, VisualStyle, Theme, TileLayout, LabelBehavior, TreemapColorScale, ViewMode, ResolvedLabelContent, ChartFormatter } from '../personalization';
+import { Hierarchy } from './hierarchy';
+import { HoverState, TreemapChartBaseProps, TreemapChartTooltipProps } from './treemap-chart-helpers';
+export interface TreemapChartProviderSnapshot {
+    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 TreemapChartRenderContext {
+    personalization: Personalization;
+    formatter: ChartFormatter;
+    resolvedLocaleBase: string;
+    resolvedTimeZone: string | undefined;
+    hierarchy: Hierarchy;
+    /** Current root path (controlled or internal). Used by adapters to render breadcrumbs. */
+    currentPath: readonly string[];
+    /** Resolved root index for the current view (drill-down) - 0 in nested mode. */
+    rootIdx: number;
+    resolvedTileLayout: TileLayout;
+    resolvedLabelBehavior: LabelBehavior;
+    resolvedColorScale: TreemapColorScale;
+    resolvedViewMode: ViewMode;
+    resolvedLabelContent: ResolvedLabelContent;
+    showBreadcrumb: boolean;
+    totalValue: number;
+    ariaLabel: string;
+    cssWidth: number;
+    cssHeight: number;
+}
+export interface TreemapChartControllerCallbacks {
+    onContextChange(ctx: TreemapChartRenderContext): void;
+    onHoverChange(hover: HoverState | null): void;
+}
+export interface TreemapChartControllerProps extends TreemapChartBaseProps {
+    tooltip?: undefined | false | ((p: TreemapChartTooltipProps) => unknown);
+}
+export interface TreemapChartControllerMountOptions extends TreemapChartControllerCallbacks {
+    /** Outer container DOM node. Visibility source pauses draws when the
+     *  chart is off-screen / in a hidden tab. */
+    container?: HTMLElement | null;
+    staticCanvas: HTMLCanvasElement;
+    dynamicCanvas: HTMLCanvasElement | null;
+    initialProps: TreemapChartControllerProps;
+    initialProvider: TreemapChartProviderSnapshot;
+}
+export declare class TreemapChartController {
+    private staticCanvas;
+    private dynamicCanvas;
+    private callbacks;
+    private props;
+    private providerCtx;
+    private handle;
+    private hoverState;
+    private dynCfg;
+    private hierarchy;
+    private personalization;
+    private resolvedLocale;
+    private formatter;
+    private resolvedTileLayout;
+    private resolvedLabelBehavior;
+    private resolvedColorScale;
+    private resolvedViewMode;
+    private resolvedLabelContent;
+    private resolvedDepthLimit;
+    /** Internal session-state path (used when host doesn't control). */
+    private internalPath;
+    private currentPath;
+    private rootIdx;
+    private nodeColors;
+    private nodeBoundsX0;
+    private nodeBoundsY0;
+    private nodeBoundsX1;
+    private nodeBoundsY1;
+    private staticDrawAbort;
+    private disposed;
+    private visGate;
+    constructor(opts: TreemapChartControllerMountOptions);
+    update(props: TreemapChartControllerProps, providerCtx: TreemapChartProviderSnapshot): void;
+    handlePointerMove(e: PointerEvent): void;
+    handlePointerLeave(): void;
+    /** Drill into a node by clicking it (drill-down mode). Adapters wire
+     *  this to onClick on the canvas. Updates internal path or fires the
+     *  onPathChange callback in controlled mode. */
+    drillTo(idx: number): void;
+    /** Adapter-level click handler - drill into the clicked tile. */
+    handleClick(e: MouseEvent): void;
+    /** Navigate breadcrumb. Adapters call this from breadcrumb clicks. */
+    setPath(newPath: readonly string[]): void;
+    dispose(): void;
+    private setHover;
+    private resolveDerived;
+    private applyDynamicCfgFromProps;
+    private runStaticDraw;
+}

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

@@ -0,0 +1,163 @@
+import { Personalization, ThemeInput, DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat, LegendPosition, LegendVisibility, TileLayout, LabelBehavior, DepthLimitInput, TreemapColorScale, ViewMode, LabelContentInput, ResolvedLabelContent, ChartFormatter } from '../personalization';
+import { Viewport } from '../viewport/viewport-sizer';
+import { CrosshairMarker } from '../rendering/draw/crosshair';
+import { GridStyle } from '../rendering/draw/grid';
+import { Hierarchy, HierarchyNode } from './hierarchy';
+export type { HierarchyNode } from './hierarchy';
+export interface TreemapChartTooltipProps {
+    readonly idx: number;
+    readonly name: string;
+    readonly value: number;
+    readonly percent: number;
+    readonly depth: number;
+    readonly path: readonly string[];
+    readonly color: 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 TreemapChartBaseProps {
+    /** Root hierarchy - `{ name, value?, children? }`. The chart packs
+     *  children into rectangles proportional to their value. */
+    data?: HierarchyNode;
+    /** Default 'squarify'. */
+    tileLayout?: TileLayout;
+    /** Default 2 px. */
+    tilePadding?: number;
+    /** Default 4 px. */
+    parentChildPadding?: number;
+    /** Default 'auto'. */
+    labelBehavior?: LabelBehavior;
+    /** Default 'name + percent'. */
+    labelContent?: LabelContentInput;
+    /** Default 'all'. */
+    depthLimit?: DepthLimitInput;
+    /** Default 'flat-categorical'. */
+    colorScale?: TreemapColorScale;
+    /** Default 'nested'. */
+    viewMode?: ViewMode;
+    /** Default true (drill-down only). */
+    breadcrumb?: boolean;
+    /** Controlled-mode current path (drill-down only). When omitted, the
+     *  controller manages an internal session-state path. */
+    currentPath?: readonly string[];
+    /** Controlled-mode change handler. Required if `currentPath` is set. */
+    onPathChange?: (path: readonly string[]) => void;
+    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_LABEL_FONT_SIZE = 11;
+export declare const DEFAULT_TILE_PADDING_PX = 4;
+export declare const DEFAULT_PARENT_CHILD_PADDING_PX = 2;
+export declare const BREADCRUMB_HEIGHT_PX = 28;
+export interface HoverState {
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly idx: number;
+    readonly name: string;
+    readonly value: number;
+    readonly percent: number;
+    readonly depth: number;
+    readonly path: readonly string[];
+    readonly color: string;
+}
+export interface DynamicCfg {
+    readonly crosshairVisible: boolean;
+    readonly crosshairLineStyle: GridStyle;
+    readonly crosshairMarker: CrosshairMarker;
+}
+export interface ChartLayout {
+    innerLeft: number;
+    innerRight: number;
+    innerTop: number;
+    innerBottom: number;
+    /** Per-node bounds (length = h.length). */
+    x0: Float64Array;
+    y0: Float64Array;
+    x1: Float64Array;
+    y1: Float64Array;
+    /** Subtree root index (drill-down: this is the node currently displayed; nested: root = 0). */
+    rootIdx: number;
+    /** Effective max depth to render (relative to rootIdx). */
+    maxRelativeDepth: number;
+    viewport: Viewport;
+}
+export interface ChartHandle {
+    readonly dynamicCtx: CanvasRenderingContext2D | null;
+    readonly layout: ChartLayout;
+    readonly crosshairLineColor: string;
+    readonly crosshairMarkerStroke: string;
+    /** Per-node CSS colors. */
+    readonly nodeColors: readonly string[];
+}
+export declare function defaultAriaLabel(h: Hierarchy): string;
+/** Build a path of names from root to `idx`. */
+export declare function pathTo(h: Hierarchy, idx: number): readonly string[];
+/**
+ *  `parentColorMode` controls how non-leaf nodes are colored under the
+ *  `directional` scale:
+ *    - "neutral" (treemap default): parents render as muted neutral
+ *      because in a treemap they CONTAIN their children - coloring them
+ *      directionally would compete visually with the children inside.
+ *    - "directional" (sunburst): parents sit on their OWN radial ring,
+ *      separate from children, so they get their aggregated direction
+ *      color just like leaves do.
+ */
+export declare function resolveTreemapColors(h: Hierarchy, rootIdx: number, scale: TreemapColorScale, variant: import('../personalization/palette/types').PaletteVariant, viewMode?: ViewMode, _palette?: import('../personalization/palette/types').Palette, _theme?: import('../personalization/palette/types').Theme, parentColorMode?: "neutral" | "directional"): readonly string[];
+export interface DrawFullTreemapArgs {
+    ctx: CanvasRenderingContext2D;
+    h: Hierarchy;
+    layout: ChartLayout;
+    nodeColors: readonly string[];
+    personalization: Personalization;
+    cornerRadius: number;
+    borderWidth: number;
+    labelBehavior: LabelBehavior;
+    resolvedLabelContent: ResolvedLabelContent;
+    formatter: ChartFormatter;
+    totalValue: number;
+    viewMode: ViewMode;
+}
+export declare function drawFullTreemapChart(args: DrawFullTreemapArgs): void;
+export declare function drawTreemapDynamicLayer(handle: ChartHandle, hover: HoverState | null, cfg: DynamicCfg): void;
+export declare function findTileAt(h: Hierarchy, layout: ChartLayout, px: number, py: number, viewMode: ViewMode): number;

package/dist/charts/treemap-layout.d.ts

@@ -0,0 +1,29 @@
+import { TileLayout } from '../personalization/axes/tile-layout';
+import { Hierarchy } from './hierarchy';
+export interface TreemapBounds {
+    /** Outer rect of the layout. */
+    readonly x0: number;
+    readonly y0: number;
+    readonly x1: number;
+    readonly y1: number;
+    /** Inset between siblings, in pixels. */
+    readonly padding: number;
+    /** Extra inset for nested children inside their parent (creates a
+     *  visible "frame" effect for hierarchy). */
+    readonly parentChildPadding: number;
+    /** Extra top inset on parent tiles to reserve space for the sector
+     *  header label. Applied only at the level *above* leaves in
+     *  multi-depth nested treemaps (so the sector container reserves
+     *  room for "Banking 3.9B ▼ 1.7%" at its top without overlapping
+     *  the ticker tiles inside). 0 / undefined = no reservation. */
+    readonly headerPadding?: number;
+}
+/** Lay out the entire hierarchy into the caller-owned `x0/y0/x1/y1` arrays.
+ *  `length` of each must equal `h.length`. The root's bounds come from
+ *  `bounds`; children recurse inside their parent's bounds minus padding. */
+export declare function layoutTreemap(h: Hierarchy, layout: TileLayout, bounds: TreemapBounds, x0: Float64Array, y0: Float64Array, x1: Float64Array, y1: Float64Array): void;
+/** Re-lay-out only the subtree rooted at `rootIdx` inside the given
+ *  bounds. The root's own bounds are set to `bounds.{x0,y0,x1,y1}` and
+ *  its descendants recurse inside that rect. Used by drill-down to
+ *  make a non-root subtree fill the whole chart area. */
+export declare function layoutTreemapSubtree(h: Hierarchy, rootIdx: number, layout: TileLayout, bounds: TreemapBounds, x0: Float64Array, y0: Float64Array, x1: Float64Array, y1: Float64Array): void;

package/dist/charts/types.d.ts

@@ -0,0 +1,38 @@
+export interface ChartControllerHandle<TProps, THandle = void> {
+    /** Replace the controller's prop snapshot. Triggers a redraw on next frame. */
+    update(props: TProps): void;
+    /** Release all resources: cancel rAF, disconnect observers, dispose engine handles. Idempotent. */
+    dispose(): void;
+    /**
+     * Imperative handle exposed to host code via the adapter's ref. Charts that
+     * have no imperative API set this to `void`; charts like CandleChart return a
+     * concrete object with methods (e.g. `startTrendline()`).
+     */
+    readonly handle: THandle;
+}
+/**
+ * Mount options every controller accepts. The adapter passes the host-provided
+ * container DOM node + initial props; the controller does the rest.
+ */
+export interface ChartControllerMountOptions<TProps> {
+    /** The host container element. Adapter creates it via its framework's JSX. */
+    container: HTMLElement;
+    /** Initial props snapshot. Subsequent prop changes flow via `update()`. */
+    initialProps: TProps;
+    /**
+     * Optional cross-chart context (theme defaults, palette registry, locale,
+     * shared engine session). Adapter resolves it from its provider and hands it
+     * in here. `null` is acceptable - controllers fall back to library defaults.
+     */
+    context?: ChartsControllerContext | null;
+}
+/**
+ * Subset of personalization-provider state that controllers consume directly.
+ * Keep this framework-free - it's a plain object the adapter populates from
+ * its ChartsProvider.
+ */
+export interface ChartsControllerContext {
+    readonly version: number;
+}
+/** Constructor signature for a chart controller. */
+export type ChartControllerConstructor<TProps, THandle = void> = new (options: ChartControllerMountOptions<TProps>) => ChartControllerHandle<TProps, THandle>;