@perspective-dev/viewer-charts 4.3.0

package/dist/esm/axis/axis-primitives.d.ts

@@ -0,0 +1,24 @@
+import type { Context2D } from "../charts/canvas-types";
+import type { PlotRect } from "../layout/plot-layout";
+export declare const TICK_SIZE = 5;
+/**
+ * One horizontal row of numeric axis ticks + labels at CSS-pixel `axisY`.
+ * `side` selects tick direction (down into the bottom margin or up into
+ * the top margin) and the corresponding label baseline. Caller owns
+ * `strokeStyle`, `fillStyle`, `font`, and `lineWidth`.
+ */
+export declare function drawXTickRow(ctx: Context2D, plot: PlotRect, ticks: number[], axisY: number, side: "top" | "bottom", xToPixel: (v: number) => number, format: (v: number) => string): void;
+/**
+ * One vertical column of numeric axis ticks + labels at CSS-pixel `axisX`.
+ * `side` selects tick direction (out toward the left or right margin) and
+ * the corresponding label alignment. Caller owns styling state.
+ */
+export declare function drawYTickColumn(ctx: Context2D, plot: PlotRect, ticks: number[], axisX: number, side: "left" | "right", yToPixel: (v: number) => number, format: (v: number) => string): void;
+/**
+ * Vertical gridlines at numeric X ticks, clipped to `plot`.
+ */
+export declare function drawGridlinesX(ctx: Context2D, plot: PlotRect, ticks: number[], xToPixel: (v: number) => number): void;
+/**
+ * Horizontal gridlines at numeric Y ticks, clipped to `plot`.
+ */
+export declare function drawGridlinesY(ctx: Context2D, plot: PlotRect, ticks: number[], yToPixel: (v: number) => number): void;

package/dist/esm/axis/bar-axis.d.ts

@@ -0,0 +1,51 @@
+import type { Canvas2D, Context2D } from "../charts/canvas-types";
+import { PlotLayout } from "../layout/plot-layout";
+import { type CategoricalDomain } from "./categorical-axis";
+import type { AxisDomain } from "./numeric-axis";
+import type { Theme } from "../theme/theme";
+/**
+ * The category-axis side of a bar chart can render as either a
+ * stringified hierarchical category axis or a true numeric axis (when
+ * the single group_by level is date / datetime / integer / float).
+ * Both shapes flow through `renderBarAxesChrome`; the discriminator is
+ * the `mode` field.
+ */
+export type BarCategoryAxis = {
+    mode: "category";
+    domain: CategoricalDomain;
+} | {
+    mode: "numeric";
+    domain: AxisDomain;
+    ticks: number[];
+};
+/**
+ * Render a numeric date-aware axis along the bottom of the plot. Aliases
+ * the bar-axis bottom variant so heatmap can share the implementation.
+ */
+export declare function drawNumericCategoryX(ctx: Context2D, layout: PlotLayout, domain: AxisDomain, ticks: number[], theme: Theme, formatter?: (v: number) => string): void;
+export declare function drawNumericCategoryY(ctx: Context2D, layout: PlotLayout, domain: AxisDomain, ticks: number[], theme: Theme, formatter?: (v: number) => string): void;
+/**
+ * Render bar-chart chrome: L-shaped axis lines, a categorical axis
+ * (bottom for Y Bar, left for X Bar), and one or two numeric axes on
+ * the opposite sides.
+ *
+ * `isHorizontal=true` flips orientation for X Bar: categorical axis on
+ * the left, numeric axes on the bottom (and top for dual-axis). The
+ * `altDomain`/`altTicks` arguments always describe the *secondary*
+ * numeric axis regardless of orientation.
+ */
+export interface BarAxesFormatters {
+    /** Formatter for the value (Y in vertical, X in horizontal) axis. */
+    value?: (v: number) => string;
+    /** Formatter for the secondary alt value axis. */
+    alt?: (v: number) => string;
+    /** Formatter for the numeric category axis (when `catAxis.mode === "numeric"`). */
+    category?: (v: number) => string;
+}
+export declare function renderBarAxesChrome(canvas: Canvas2D, catAxis: BarCategoryAxis, valueDomain: AxisDomain, valueTicks: number[], layout: PlotLayout, theme: Theme, dpr: number, altDomain?: AxisDomain, altTicks?: number[], isHorizontal?: boolean, formatters?: BarAxesFormatters): void;
+/**
+ * Render gridlines at the numeric axis ticks. In vertical bar charts
+ * the gridlines run horizontally at numeric Y ticks; in horizontal bar
+ * charts they run vertically at numeric X ticks.
+ */
+export declare function renderBarGridlines(canvas: Canvas2D, layout: PlotLayout, valueTicks: number[], theme: Theme, dpr: number, isHorizontal?: boolean): void;

package/dist/esm/axis/canvas.d.ts

@@ -0,0 +1,24 @@
+import type { Canvas2D, Context2D } from "../charts/canvas-types";
+import type { PlotLayout } from "../layout/plot-layout";
+/**
+ * Destructive per-frame canvas setup: resize to CSS pixels × DPR,
+ * clear, and return a DPR-scaled 2D context. Call this exactly once
+ * per canvas per frame — setting `canvas.width` / `canvas.height`
+ * always wipes the bitmap and resets the transform, so calling it in
+ * a per-facet loop wipes every previously-drawn facet.
+ *
+ * Faceted renderers call this once per frame and then
+ * {@link getScaledContext} per facet to obtain the same context
+ * without re-wiping.
+ */
+export declare function initCanvas(canvas: Canvas2D, layout: PlotLayout, dpr: number): Context2D | null;
+/**
+ * Non-destructive variant: returns the 2D context with its transform
+ * forced to `scale(dpr, dpr)` via `setTransform` (idempotent — no
+ * stacking). Assumes `initCanvas` was already called on this canvas
+ * this frame; does NOT resize or clear.
+ *
+ * Intended for per-facet render helpers that must not wipe the shared
+ * canvas bitmap mid-frame.
+ */
+export declare function getScaledContext(canvas: Canvas2D, dpr: number): Context2D | null;

package/dist/esm/axis/categorical-axis-core.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Orientation-neutral helpers shared by the horizontal and vertical
+ * hierarchical categorical axes. Both axis painters specialize on top of
+ * this core; the only thing they disagree on is where bracket lines and
+ * leaf labels land on the plot chrome.
+ */
+/**
+ * One run of consecutive equal dictionary indices in a level's `indices`
+ * array, with the label pre-resolved. Used by the outer-level bracket
+ * renderer to coalesce a span of contiguous cells into a single labelled
+ * group.
+ */
+export interface GroupRun {
+    startIdx: number;
+    /**
+     * Inclusive.
+     */
+    endIdx: number;
+    label: string;
+}
+/**
+ * Single-pass run-length encoding of `indices[startRow..endRow)` keyed
+ * by `dictionary`. Relies on perspective's guarantee that rows sharing
+ * an outer-level dictionary entry are emitted contiguously in traversal
+ * order — equal neighbours always belong to the same span. The emitted
+ * `label` is a direct reference into `dictionary` (no per-row copy).
+ */
+export declare function buildGroupRuns(indices: Int32Array | ArrayLike<number>, dictionary: string[], startRow: number, endRow: number): GroupRun[];
+/**
+ * Longest string length in a dictionary. O(dictSize), not O(numRows).
+ * Drives the rotation decision on the leaf level of the X axis and the
+ * column-width decision on the Y axis.
+ */
+export declare function maxDictLength(dictionary: string[]): number;
+/**
+ * Filter a precomputed `runs` array to those whose index range
+ * intersects `[visMin, visMax]` (inclusive on both sides). Runs that
+ * straddle an endpoint are clipped so the caller sees `startIdx`/
+ * `endIdx` pinned to the visible slice — this matches the legacy
+ * `buildGroupRuns(indices, visMin, visMax + 1)` return shape.
+ */
+export declare function runsInRange(runs: GroupRun[], visMin: number, visMax: number): GroupRun[];

package/dist/esm/axis/categorical-axis.d.ts

@@ -0,0 +1,27 @@
+import type { Context2D } from "../charts/canvas-types";
+import { PlotLayout } from "../layout/plot-layout";
+import { type GroupRun } from "./categorical-axis-core";
+import type { Theme } from "../theme/theme";
+export interface CategoricalLevel {
+    labels: string[];
+    runs: GroupRun[];
+    maxLabelChars: number;
+}
+export interface CategoricalDomain {
+    levels: CategoricalLevel[];
+    numRows: number;
+    levelLabels: string[];
+}
+interface LevelTickLayout {
+    size: number;
+    rotation: 0 | 45 | 90;
+}
+declare function categoryIndexToPixelX(layout: PlotLayout, index: number): number;
+export declare const categoryIndexToPixel: typeof categoryIndexToPixelX;
+export declare function measureCategoricalLevels(domain: CategoricalDomain, plotWidth: number): LevelTickLayout[];
+export declare function measureCategoricalLevelWidths(domain: CategoricalDomain): number[];
+export declare function measureCategoricalAxisHeight(domain: CategoricalDomain, plotWidth: number): number;
+export declare function measureCategoricalAxisWidth(domain: CategoricalDomain): number;
+export declare function renderCategoricalXTicks(ctx: Context2D, layout: PlotLayout, domain: CategoricalDomain, theme: Theme): void;
+export declare function renderCategoricalYTicks(ctx: Context2D, layout: PlotLayout, domain: CategoricalDomain, theme: Theme): void;
+export {};

package/dist/esm/axis/facet-chrome.d.ts

@@ -0,0 +1,13 @@
+import type { Canvas2D } from "../charts/canvas-types";
+import type { Theme } from "../theme/theme";
+/**
+ * Paint a single facet's title strip — one line of centered text in the
+ * caller-supplied `rect`. Shared by every faceted chart family
+ * (cartesian, heatmap, …) so the title typography stays uniform.
+ */
+export declare function drawFacetTitle(canvas: Canvas2D, label: string, rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, theme: Theme, dpr: number): void;

package/dist/esm/axis/label-geometry.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Generic pixel-space label geometry helpers shared by the axis,
+ * legend, and tooltip overlays.
+ *
+ * All rectangles are in CSS pixels, origin top-left, Y-axis pointing down.
+ */
+import type { Context2D } from "../charts/canvas-types";
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export type Rotation = 0 | 45 | 90;
+/**
+ * Bounding rectangle of a text label anchored at `(cx, cy)`, accounting for
+ * rotation. Matches d3fc's approximation of rotated text bounds.
+ */
+export declare function labelRect(cx: number, cy: number, textWidth: number, textHeight: number, rotation: Rotation): Rect;
+export declare function rectsOverlap(a: Rect, b: Rect): boolean;
+/**
+ * Rotated-label overlap heuristic from d3fc: for steeply-rotated labels
+ * the right edge of the previous box must precede the right edge of the
+ * next (plus a small gap).
+ */
+export declare function rotatedLabelsOverlap(a: Rect, b: Rect): boolean;
+export declare function rectContained(inner: Rect, outer: Rect): boolean;
+/**
+ * Truncate `label` with a trailing ellipsis so the rendered width fits
+ * within `maxWidth`. Returns "" when even one character would overflow.
+ */
+export declare function truncateLabel(ctx: Context2D, label: string, maxWidth: number): string;
+/**
+ * Word-wrap `text` into at most `maxLines` lines, each fitting within
+ * `maxWidth`. Breaks at the last whitespace before the fit boundary
+ * when possible, falls back to a hard character break otherwise. The
+ * final line is ellipsis-truncated via {@link truncateLabel} if it
+ * still doesn't fit. Returns `[]` when nothing meaningful fits (only
+ * one line of ≤ 2 chars after wrapping).
+ */
+export declare function wrapLabel(ctx: Context2D, text: string, maxWidth: number, maxLines: number): string[];

package/dist/esm/axis/legend.d.ts

@@ -0,0 +1,44 @@
+import type { Canvas2D } from "../charts/canvas-types";
+import type { PlotLayout, PlotRect } from "../layout/plot-layout";
+import { type GradientStop } from "../theme/gradient";
+import type { Theme } from "../theme/theme";
+/**
+ * Render a vertical color gradient legend on the Canvas2D overlay.
+ * Only call when a color column is active. When `colorDomain` crosses
+ * zero the 50% stop (sign pivot) is annotated with a tick + `0` label.
+ *
+ * Per-facet wrapper; computes the anchor from `layout` and delegates
+ * to {@link renderLegendAt}. Facet grids render one shared gradient
+ * legend and pass an explicit rect to `renderLegendAt` directly.
+ */
+export declare function renderLegend(canvas: Canvas2D, layout: PlotLayout, colorDomain: {
+    min: number;
+    max: number;
+    label: string;
+}, stops: GradientStop[], theme: Theme, formatter?: (v: number) => string): void;
+/**
+ * Render a gradient legend at an explicit canvas-absolute rect.
+ * Used by facet grids that paint one legend for the whole grid and
+ * by single-plot charts through {@link renderLegend}.
+ */
+export declare function renderLegendAt(canvas: Canvas2D, rect: PlotRect, colorDomain: {
+    min: number;
+    max: number;
+    label: string;
+}, stops: GradientStop[], theme: Theme, formatter?: (v: number) => string): void;
+/**
+ * Render a categorical legend with discrete colored swatches.
+ * Used when split_by or string color columns produce distinct categories.
+ *
+ * The per-facet wrapper; computes the anchor from `layout` and delegates
+ * to {@link renderCategoricalLegendAt}. Facet grids that render one
+ * shared legend pass an explicit rect to `renderCategoricalLegendAt`
+ * directly.
+ */
+export declare function renderCategoricalLegend(canvas: Canvas2D, layout: PlotLayout, labels: Map<string, number>, palette: [number, number, number][], theme: Theme): void;
+/**
+ * Render a categorical legend at an explicit canvas-absolute rect.
+ * Used by facet grids that paint one legend for the whole grid and by
+ * single-plot charts through {@link renderCategoricalLegend}.
+ */
+export declare function renderCategoricalLegendAt(canvas: Canvas2D, rect: PlotRect, labels: Map<string, number>, palette: [number, number, number][], theme: Theme): void;

package/dist/esm/axis/numeric-axis.d.ts

@@ -0,0 +1,20 @@
+import type { Canvas2D } from "../charts/canvas-types";
+import { PlotLayout, type PlotRect } from "../layout/plot-layout";
+import type { Theme } from "../theme/theme";
+export interface AxisDomain {
+    min: number;
+    max: number;
+    label: string;
+    isDate?: boolean;
+}
+export interface TickResult {
+    xTicks: number[];
+    yTicks: number[];
+}
+export declare function computeTicks(xDomain: AxisDomain, yDomain: AxisDomain, layout: PlotLayout): TickResult;
+export declare function renderGridlines(canvas: Canvas2D, layout: PlotLayout, xTicks: number[], yTicks: number[], theme: Theme, dpr: number): void;
+export declare function renderCellXAxis(canvas: Canvas2D, xDomain: AxisDomain, layout: PlotLayout, xTicks: number[], theme: Theme, hasLabel: boolean, dpr: number, formatter?: (v: number) => string): void;
+export declare function renderCellYAxis(canvas: Canvas2D, yDomain: AxisDomain, layout: PlotLayout, yTicks: number[], theme: Theme, hasLabel: boolean, dpr: number, formatter?: (v: number) => string): void;
+export declare function renderAxesChrome(canvas: Canvas2D, xDomain: AxisDomain, yDomain: AxisDomain, layout: PlotLayout, xTicks: number[], yTicks: number[], theme: Theme, dpr: number, xFormatter?: (v: number) => string, yFormatter?: (v: number) => string): void;
+export declare function renderOuterXAxis(canvas: Canvas2D, rect: PlotRect, xDomain: AxisDomain, xTicks: number[], colLayouts: PlotLayout[], theme: Theme, hasLabel: boolean, dpr: number, formatter?: (v: number) => string): void;
+export declare function renderOuterYAxis(canvas: Canvas2D, rect: PlotRect, yDomain: AxisDomain, yTicks: number[], rowLayouts: PlotLayout[], theme: Theme, hasLabel: boolean, dpr: number, formatter?: (v: number) => string): void;

package/dist/esm/charts/candlestick/candlestick-build.d.ts

@@ -0,0 +1,129 @@
+import type { ColumnDataMap } from "../../data/view-reader";
+import type { CategoricalLevel } from "../../axis/categorical-axis";
+import { type AxisMode, type NumericCategoryDomain } from "../common/category-axis-resolver";
+export interface CandleSeriesInfo {
+    seriesId: number;
+    splitIdx: number;
+    splitKey: string;
+    label: string;
+}
+/**
+ * Logical candle record. Synthesized on demand from {@link CandleColumns}
+ * via {@link readCandleRecord} for tooltip / hover paths. The pipeline
+ * never materializes these — see `CandleColumns` for the columnar
+ * storage that replaces the legacy `CandleRecord[]`.
+ */
+export interface CandleRecord {
+    catIdx: number;
+    splitIdx: number;
+    seriesId: number;
+    xCenter: number;
+    halfWidth: number;
+    open: number;
+    close: number;
+    high: number;
+    low: number;
+    isUp: boolean;
+}
+/**
+ * Columnar storage for the candle record set. Replaces the legacy
+ * `CandleRecord[]` to avoid per-record POJO allocation at scale.
+ *
+ * Records are appended in `(splitIdx, catIdx)` order as the pipeline
+ * loop is structured (outer split, inner category) — both `xCenter` and
+ * `catIdx` are monotonically non-decreasing within a split, which the
+ * hit-test uses for binary-search narrowing.
+ *
+ * `count` is the active record count; the underlying typed arrays may
+ * be over-allocated for capacity reuse across builds.
+ */
+export interface CandleColumns {
+    count: number;
+    catIdx: Int32Array;
+    splitIdx: Int32Array;
+    seriesId: Int32Array;
+    xCenter: Float64Array;
+    halfWidth: Float64Array;
+    open: Float64Array;
+    close: Float64Array;
+    high: Float64Array;
+    low: Float64Array;
+    /**
+     * 1 = up (close ≥ open), 0 = down.
+     */
+    isUp: Uint8Array;
+}
+export declare function emptyCandleColumns(): CandleColumns;
+/**
+ * Reuse `prev`'s typed arrays when capacity is sufficient, else allocate
+ * fresh. Resets `count` to 0; pipeline writes from index 0.
+ */
+export declare function ensureCandleColumnsCapacity(prev: CandleColumns | null, capacity: number): CandleColumns;
+/**
+ * Synthesize a {@link CandleRecord} POJO for record `i`. Used by
+ * tooltip / pinned tooltip / hover return paths; not called in any
+ * frame-rate hot loop.
+ */
+export declare function readCandleRecord(cols: CandleColumns, i: number): CandleRecord;
+export interface CandlestickPipelineInput {
+    columns: ColumnDataMap;
+    numRows: number;
+    columnSlots: (string | null)[];
+    groupBy: string[];
+    splitBy: string[];
+    /**
+     * Source-column types for `group_by` columns. Same shape as the bar
+     * pipeline — used to stringify non-string row-paths and to enable
+     * numeric-axis mode for a single non-string non-boolean group_by.
+     */
+    groupByTypes: Record<string, string>;
+    /**
+     * Band-slot geometry knobs sourced from
+     * {@link PluginConfig.band_inner_frac} / `bar_inner_pad`. Forwarded
+     * to `computeSlotGeometry`. Replace the `BAND_INNER_FRAC` /
+     * `BAR_INNER_PAD` constants.
+     */
+    bandInnerFrac: number;
+    barInnerPad: number;
+    /**
+     * Reusable scratch — pipeline writes records into the typed arrays
+     * in place. Pass the previous build's columns to amortize
+     * allocation across data reloads.
+     */
+    scratchCandles?: CandleColumns | null;
+}
+export type { NumericCategoryDomain };
+export interface CandlestickPipelineResult {
+    splitPrefixes: string[];
+    rowPaths: CategoricalLevel[];
+    numCategories: number;
+    rowOffset: number;
+    /**
+     * Axis mode discriminator (see bar-build for semantics).
+     */
+    axisMode: AxisMode;
+    numericCategoryDomain: NumericCategoryDomain | null;
+    /**
+     * Per-category X position (real data units) in numeric mode.
+     */
+    categoryPositions: Float64Array | null;
+    series: CandleSeriesInfo[];
+    candles: CandleColumns;
+    yDomain: {
+        min: number;
+        max: number;
+    };
+}
+/**
+ * Pure pipeline: turn a raw `ColumnDataMap` into a columnar
+ * {@link CandleColumns}. Column slots (Open / Close / High / Low) mirror
+ * d3fc's convention:
+ *   - `Open` is required.
+ *   - `Close` falls back to the next row's Open (last row: own Open).
+ *   - `High` falls back to `max(open, close)`.
+ *   - `Low` falls back to `min(open, close)`.
+ *
+ * The fallbacks apply per series when `split_by` is active, so each
+ * split reads the "next row" from its own series.
+ */
+export declare function buildCandlestickPipeline(input: CandlestickPipelineInput): CandlestickPipelineResult;

package/dist/esm/charts/candlestick/candlestick-interact.d.ts

@@ -0,0 +1,10 @@
+import type { CandlestickChart } from "./candlestick";
+export declare function handleCandlestickHover(chart: CandlestickChart, mx: number, my: number): void;
+export declare function showCandlestickPinnedTooltip(chart: CandlestickChart, idx: number): void;
+export declare function dismissCandlestickPinnedTooltip(chart: CandlestickChart): void;
+/**
+ * Build tooltip lines for candle at index `idx` in the columnar
+ * storage. Indexed access avoids materializing a `CandleRecord` POJO
+ * on the hot tooltip path.
+ */
+export declare function buildCandlestickTooltipLines(chart: CandlestickChart, idx: number): string[];

package/dist/esm/charts/candlestick/candlestick-render.d.ts

@@ -0,0 +1,24 @@
+import type { WebGLContextManager } from "../../webgl/context-manager";
+import type { CandlestickChart } from "./candlestick";
+/**
+ * Resolve up/down body colors from `theme.gradientStops`. Cached on the
+ * chart via `_upDownColorKey` (reference identity of the stops array)
+ * — only `restyle()` (which clears the theme cache via
+ * `invalidateTheme`) or a data load with a fresh theme triggers
+ * resampling. Legacy code re-sampled every frame.
+ */
+export declare function ensureUpDownColors(chart: CandlestickChart): void;
+/**
+ * Drop persistent body / wick / OHLC vertex buffers. Subsequent draws
+ * no-op until the next {@link rebuildGlyphBuffers} call.
+ */
+export declare function invalidateGlyphBuffers(chart: CandlestickChart): void;
+/**
+ * Rebuild the persistent body / wick / OHLC vertex buffers. Reads
+ * `_candles` (columnar) plus the cached `_upColor` / `_downColor` to
+ * populate the GPU buffers exactly once per data load. Subsequent pan/
+ * zoom redraws bind + dispatch with no uploads.
+ */
+export declare function rebuildGlyphBuffers(chart: CandlestickChart, glManager: WebGLContextManager): void;
+export declare function renderCandlestickFrame(chart: CandlestickChart, glManager: WebGLContextManager): void;
+export declare function renderCandlestickChromeOverlay(chart: CandlestickChart): void;

package/dist/esm/charts/candlestick/candlestick.d.ts

@@ -0,0 +1,144 @@
+import type { ColumnDataMap } from "../../data/view-reader";
+import type { WebGLContextManager } from "../../webgl/context-manager";
+import { CategoricalYChart } from "../common/categorical-y-chart";
+import { type CandleColumns, type CandleSeriesInfo, type NumericCategoryDomain } from "./candlestick-build";
+import { BodyWickGlyph } from "./glyphs/draw-candlesticks";
+import { OHLCGlyph } from "./glyphs/draw-ohlc";
+/**
+ * Per-frame memo of the auto-fit Y extent for a {@link CandlestickChart},
+ * keyed on the visible X window. Hover-only redraws hit the cache.
+ */
+export interface CandlestickAutoFitCache {
+    xMin: number;
+    xMax: number;
+    min: number;
+    max: number;
+    hasFit: boolean;
+}
+export interface CandlestickLocations {
+    u_proj_left: WebGLUniformLocation | null;
+    u_proj_right: WebGLUniformLocation | null;
+    u_hover_series: WebGLUniformLocation | null;
+    a_corner: number;
+    a_x_center: number;
+    a_half_width: number;
+    a_y0: number;
+    a_y1: number;
+    a_color: number;
+    a_series_id: number;
+    a_axis: number;
+}
+/**
+ * Candlestick / OHLC chart. Both plugins (`y-candlestick`, `y-ohlc`)
+ * share this class — the only per-plugin difference is
+ * `_defaultChartType` (`"candlestick"` vs `"ohlc"`), which
+ * {@link renderCandlestickFrame} uses to pick the glyph draw function.
+ *
+ * Fields are package-internal (no `private`) so helper modules in this
+ * folder can read/write them.
+ */
+export declare class CandlestickChart extends CategoricalYChart {
+    _locations: CandlestickLocations | null;
+    _splitPrefixes: string[];
+    _series: CandleSeriesInfo[];
+    /**
+     * Columnar candle records. Indexed in `[0, _candles.count)`.
+     * Replaces the legacy `CandleRecord[]` to avoid per-record POJO
+     * allocation on data load.
+     */
+    _candles: CandleColumns;
+    _yDomain: {
+        min: number;
+        max: number;
+    };
+    /**
+     * `domain_mode: "expand"` accumulators. Hold the running union of
+     * the value-axis (and, in numeric-category mode, category-axis)
+     * extent across data loads. Cleared in `resetExpandedDomain` —
+     * wired from the worker's `resetAllZooms` and from view-config
+     * mutations on `AbstractChart`. `null` whenever the option is
+     * `"fit"` or the accumulator has just been cleared.
+     */
+    _expandedYDomain: {
+        min: number;
+        max: number;
+    } | null;
+    _expandedCategoryDomain: {
+        min: number;
+        max: number;
+    } | null;
+    /**
+     * Numeric category-axis state (single non-string group_by).
+     */
+    _categoryAxisMode: "category" | "numeric";
+    _numericCategoryDomain: NumericCategoryDomain | null;
+    _categoryPositions: Float64Array | null;
+    _lastCatTicks: number[] | null;
+    /**
+     * Origin used to rebase candle xCenters before f32 narrowing — see {@link SeriesChart._categoryOrigin}.
+     */
+    _categoryOrigin: number;
+    /**
+     * Gradient-sampled colors for the up (close ≥ open) / down sides.
+     * Cached via `_upDownColorKey` — only `restyle()` (which clears the
+     * theme cache) or a data load forces re-sampling.
+     */
+    _upColor: [number, number, number];
+    _downColor: [number, number, number];
+    /**
+     * Identity of the gradient-stops reference last used to sample the
+     * up/down colors. When this matches the current `theme.gradientStops`
+     * reference, `ensureUpDownColors` short-circuits.
+     */
+    _upDownColorKey: unknown;
+    _hoveredIdx: number;
+    _pinnedIdx: number;
+    /**
+     * Typed glyph composition. Each glyph owns its own program cache
+     * and persistent vertex buffers privately; the chart routes
+     * draw/rebuild/invalidate via `_glyphs`. `_defaultChartType`
+     * (`"candlestick"` vs `"ohlc"`) selects which glyph the frame
+     * builder dispatches to.
+     */
+    readonly _glyphs: {
+        readonly bodyWick: BodyWickGlyph;
+        readonly ohlc: OHLCGlyph;
+    };
+    /**
+     * Auto-fit the price (Y) axis to the `low`/`high` extent of
+     * candles whose `xCenter` falls inside the visible X window. Pairs
+     * with the locked Y axis: the lock means user input can't zoom Y
+     * directly, auto-fit is what actually moves it as the user scrolls
+     * through time. Default: on (financial-chart convention).
+     */
+    _autoFitValue: boolean;
+    /**
+     * Per-frame memo of the auto-fit Y extent keyed on the visible X
+     * window. Hover-only redraws (X window unchanged) hit the cache.
+     * Reset to null on data upload.
+     */
+    _autoFitCache: CandlestickAutoFitCache | null;
+    protected tooltipCallbacks(): {
+        onHover: (mx: number, my: number) => void;
+        onLeave: () => void;
+        onPin: (mx: number, my: number) => void;
+        onUnpin: () => void;
+    };
+    /**
+     * Resolve a clicked candle into a `PerspectiveClickDetail` and
+     * emit both `perspective-click` and
+     * `perspective-global-filter selected:true`.
+     *
+     * One candle per (catIdx, splitIdx). Like the series pipeline,
+     * `catIdx + _rowOffset` is the source-view row; the column name is
+     * the Close column (the canonical "y" target for OHLC). Group-by
+     * values come from `_rowPaths`; split-by values come from
+     * `_splitPrefixes[splitIdx]` split on `|`.
+     */
+    private _emitCandleClickSelect;
+    invalidateTheme(): void;
+    uploadAndRender(glManager: WebGLContextManager, columns: ColumnDataMap, startRow: number, endRow: number): Promise<void>;
+    _fullRender(glManager: WebGLContextManager): void;
+    resetExpandedDomain(): void;
+    protected destroyInternal(): void;
+}

package/dist/esm/charts/candlestick/glyphs/draw-candlesticks.d.ts

@@ -0,0 +1,36 @@
+import type { WebGLContextManager } from "../../../webgl/context-manager";
+import type { CandlestickChart } from "../candlestick";
+type GL = WebGL2RenderingContext | WebGLRenderingContext;
+/**
+ * Candlestick body + wick glyph. Owns the body and wick programs +
+ * their corner/segment/instance buffers, and the persistent up/down
+ * wick vertex buffers built per data load.
+ */
+export declare class BodyWickGlyph {
+    private _program;
+    private _buffers;
+    /**
+     * Lazily compile the body and wick programs and create their static
+     * GPU buffers (corner / quad). Cached for the lifetime of the chart.
+     */
+    private ensureProgram;
+    /**
+     * Drop persistent body + wick vertex buffers. Called from data-load
+     * (before `rebuildBuffers`) and from chart-destroy paths.
+     */
+    invalidateBuffers(chart: CandlestickChart): void;
+    /**
+     * Pre-build the per-instance body buffer (interleaved
+     * [xCenter, halfWidth, y0, y1, r, g, b]) and the up/down wick
+     * line-segment buffers. Single GPU upload per buffer per data load.
+     */
+    rebuildBuffers(chart: CandlestickChart, glManager: WebGLContextManager): void;
+    draw(chart: CandlestickChart, gl: GL, glManager: WebGLContextManager, projection: Float32Array): void;
+    /**
+     * Free program-local GPU buffers + persistent vertex buffers. The
+     * shader programs themselves are owned by `WebGLContextManager.shaders`
+     * and not freed here.
+     */
+    destroy(chart: CandlestickChart): void;
+}
+export {};