@abdullahjaswal/tickyr-charts-solid 0.1.0

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

@@ -0,0 +1,781 @@
+import { CandleSeries, CandleSeriesInput, LiveState, Drawing as DrawingT, SignalMarker, OrderMarker, PositionMarker, EventMarker } from '../domain';
+import { Personalization, Palette, Theme, ThemeInput, ThemeSwitchTransition, BarEntryAnimation, BarUpdateAnimation, LiveBarIndicator, ConnectionIndicator, StaleVisualization, LegendPosition, DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat, ChartFormatter } from '../personalization';
+import { Viewport } from '../viewport/viewport-sizer';
+import { LinearScale } from '../viewport/scales/linear';
+import { LogScale } from '../viewport/scales/log';
+import { NiceTick } from '../viewport/nice-ticks';
+import { Rect } from '../rendering/dirty-rect-tracker';
+import { YAxisPosition, XAxisPosition, XAxisTick } from '../rendering/draw/axis';
+import { GridStyle } from '../rendering/draw/grid';
+import { LastPriceLineStyle } from '../rendering/draw/last-price';
+import { CrosshairMarker } from '../rendering/draw/crosshair';
+import { SignalMarkerMode, OrderMarkerMode, PositionMarkerMode, EventMarkerMode } from '../rendering/draw/markers';
+import { IndicatorPaneSpec, ResolvedRsiSpec, ResolvedMacdSpec, ResolvedStochasticSpec, ResolvedAtrSpec, IndicatorLineStyle } from '../personalization/axes/indicator-pane-spec';
+import { VolumeColoring as VolumeColoringInternal } from '../personalization/axes/volume-coloring';
+import { HighLowMarkers } from './line-chart-helpers';
+export type { HighLowMarkers } from './line-chart-helpers';
+/** Direction signal for the OHLC bar at hover. `'doji'` when the
+ *  source-data |O−C| would render below `dojiMinBodyHeight` and the chart
+ *  is showing the doji floor in `palette.doji`. */
+export type CandleDirection = "up" | "down" | "doji";
+/** Props passed to a custom CandleChart OHLC tooltip render function (and
+ *  to the built-in `DefaultCandleTooltip`). Framework-agnostic data shape. */
+export interface CandleChartTooltipProps {
+    /** Time at the active hover position (unix-ms). */
+    t: number;
+    /** Bar index in the candle series (0-based). */
+    idx: number;
+    /** Open / High / Low / Close at the hover bar. For Heikin-Ashi mode
+     *  these are the HA-transformed values (what the chart is actually
+     *  rendering); the tooltip stays consistent with what's on screen. */
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    /** Direction at hover - `'up'` if `c >= o`, `'down'` if `c < o`,
+     *  `'doji'` if the body collapsed below the floor and rendered with
+     *  `palette.doji`. */
+    direction: CandleDirection;
+    /** Pointer position in CSS pixels relative to the chart container. */
+    pointerX: number;
+    pointerY: number;
+    /** Container dimensions for placement decisions. */
+    containerWidth: number;
+    containerHeight: number;
+    theme: Theme;
+    palette: Palette;
+    locale: string;
+    timeZone: string | undefined;
+    formatter: ChartFormatter;
+}
+/** `solid` (Japanese candle), `heikin-ashi`
+ *  (smoothed via per-bar transform), `ohlc-bars` (Western tick bar). */
+export type CandleType = "solid" | "heikin-ashi" | "ohlc-bars";
+/** `'body'` = wick tracks the body's directional
+ *  color; `'neutral'` = wick uses `palette.neutral`; literal hex =
+ *  override. */
+export type WickColor = "body" | "neutral" | string;
+export type VolumePlacement = "subpane" | "overlay";
+/** Volume bar coloring mode. */
+export type VolumeColoring = "by-direction" | "single" | "by-magnitude";
+/** Volume bar scale. */
+export type VolumeScale = "linear" | "log";
+export interface SignalTooltipProps {
+    marker: import('../domain').SignalMarker;
+    /** Bar's center x in CSS px (host can use for absolute positioning). */
+    pointerX: number;
+    pointerY: number;
+    formatter: ChartFormatter;
+}
+export interface OrderTooltipProps {
+    marker: import('../domain').OrderMarker;
+    pointerX: number;
+    pointerY: number;
+    formatter: ChartFormatter;
+}
+export interface PositionTooltipProps {
+    marker: import('../domain').PositionMarker;
+    /** Live last close - for P&L snapshot in the tooltip. */
+    lastClose: number;
+    pointerX: number;
+    pointerY: number;
+    formatter: ChartFormatter;
+}
+export interface EventTooltipProps {
+    marker: import('../domain').EventMarker;
+    pointerX: number;
+    pointerY: number;
+    formatter: ChartFormatter;
+}
+export interface CandleStaleBannerRenderProps {
+    state: LiveState;
+    liveSince: number | undefined;
+    theme: Theme;
+    palette: Palette;
+}
+/** Volume-bar tooltip render-prop param shape - framework-agnostic.
+ *  Mirrors `VolumeBarTooltipProps` in both `react/tooltips/default-volume-
+ *  bar-tooltip` and `solid/tooltips/default-volume-bar-tooltip`. The
+ *  controller's `volumeBarTooltip` widens the return type to `unknown`
+ *  so both the React adapter (`React.ReactNode`) and the Solid adapter
+ *  (`JSX.Element`) pass type-check via covariance. */
+export interface VolumeBarTooltipProps {
+    bar: {
+        t: number;
+        v: number;
+        idx: number;
+    };
+    avg20: number;
+    percentile: number;
+    pointerX: number;
+    pointerY: number;
+    containerWidth: number;
+    containerHeight: number;
+    theme: Theme;
+    palette: Palette;
+    locale: string;
+    timeZone: string | undefined;
+    formatter: ChartFormatter;
+}
+/** Framework-agnostic CandleChart prop shape. Excludes the eight render-
+ *  prop fields (`tooltip`, `extremeTooltip`, `volumeBarTooltip`,
+ *  `staleBanner`, `signalTooltip`, `orderTooltip`, `positionTooltip`,
+ *  `eventTooltip`) that each framework adapter retypes against its
+ *  native JSX element type. The controller's `CandleChartControllerProps`
+ *  extends this with `unknown`-returning render props so both adapters'
+ *  shapes are structurally assignable via covariance. */
+export interface CandleChartBaseProps {
+    /** Required. OHLC(V) bars - either structured (`{ candles: Array<{t,o,h,l,c,v?}> }`)
+     *  or binary (per-field `Float64Array`). The binary path is zero-copy. */
+    data: CandleSeriesInput;
+    /** Older bars prepended to `data` for indicator warm-up. Same shape
+     *  as `data`. Lets RSI/MACD/etc. have priors so the visible window
+     *  starts post-warmup with non-NaN values. */
+    historyData?: CandleSeriesInput;
+    /** When `true` (default) and the dynamic
+     *  layer is above ~200×200 px, dirty-rect repaints clip the clear +
+     *  draw to V-strip + H-strip + live-bar regions instead of clearing
+     *  the entire canvas. Set `false` to force full-layer repaints. */
+    partialRepaints?: boolean;
+    /** VWAP price-overlay computed by the engine. When set,
+     *  the engine's `vwap(highs, lows, closes, volumes, sessionStarts)`
+     *  is computed once per data update and rendered as a line on the
+     *  price pane. Requires `data.volumes` - silently skipped when
+     *  volumes are absent. */
+    vwap?: {
+        /** Defaults to `true` when the `vwap` prop is present. */
+        visible?: boolean;
+        /** `"auto"` pulls from `palette[theme].indicators.vwap`. */
+        color?: "auto" | string;
+        /** Defaults to `indicatorLineWidth` from personalization. */
+        lineWidth?: number;
+        /** Session breakpoints - strictly-increasing indices into the
+         *  times array. Defaults to `[0]` (whole series is one session). */
+        sessionStarts?: Uint32Array;
+    };
+    /** Engine-backed streaming mode. When
+     *  set, `chart.onTick(t, p, s)` routes through the engine's
+     *  `Engine.pushTick` for validate-then-aggregate semantics:
+     *
+     *  - **Validation** - rejects non-positive prices, out-of-range
+     *    price/volume, backward timestamps (per the anomaly policy).
+     *  - **Bucket transitions** - engine returns `MutateLast` (extend
+     *    current bar) or `AppendNew` (current bar closed; new one opens)
+     *    so the controller correctly extends the series past the live bar.
+     *  - **Anomaly + audit + telemetry** - pass-through to the engine's
+     *    `setAnomalyPolicy` / `setAuditCallback` / `setTelemetryCallback`.
+     *
+     *  When omitted, `onTick` falls back to JS-side last-bar-only
+     *  mutation (suitable for hosts that own bar progression and just
+     *  want intra-bar high/low/close updates). */
+    streaming?: {
+        /** Timeframe in minutes. Must match the data's bar spacing. */
+        timeframeMinutes: number;
+        /** Market spec - controls session-aware bucketing. */
+        market: "equity" | "dst-equity" | "crypto-24-7";
+        /** Completed-candle ring capacity. */
+        capacity?: number;
+        /** Validator bounds (scaled-integer per `Market::price_scale.decimals`). */
+        minPriceRaw?: number;
+        maxPriceRaw?: number;
+        maxVolumeRaw?: number;
+        /** Optional anomaly policy. Each field accepts a negative value to
+         *  disable that specific check. */
+        anomaly?: {
+            maxRelativePriceJump?: number;
+            rejectZeroVolumeTrade?: boolean;
+            clockSkewToleranceMs?: number;
+            maxGapMs?: number;
+        };
+        /** Observability callbacks - wired into the engine's audit /
+         *  telemetry surfaces. */
+        onAudit?: (kind: number, tsMs: number, priceRaw: number, rejectReasonCode: number) => void;
+        onTelemetry?: (name: string) => void;
+    };
+    /** Candle visual: `"solid"` (default, filled bodies), `"hollow"`
+     *  (down bodies hollow), `"ohlc-bars"` (open/close ticks), or
+     *  `"heikin-ashi"` (smoothed Heikin-Ashi transform). */
+    candleType?: CandleType;
+    /** Fraction of the slot width consumed by the body (0–1). Default
+     *  0.7 - bars touch but don't overlap. */
+    bodyWidthRatio?: number;
+    /** Wick stroke width in CSS px. Default 1.4. */
+    wickWidth?: number;
+    /** Wick color rule: `"body"` (matches body color, default),
+     *  `"neutral"`, `"up"`, `"down"`. */
+    wickColor?: WickColor;
+    /** Minimum body height in CSS px so true-doji bars stay visible.
+     *  Default 1. */
+    dojiMinBodyHeight?: number;
+    /** Toggle the crosshair overlay on hover. Default `true`. */
+    crosshairVisible?: boolean;
+    /** Crosshair line style: `"solid"` / `"dashed"` / `"dotted"`. */
+    crosshairLineStyle?: GridStyle;
+    /** Snap-marker shape at the data intersection: `"circle"` / `"square"` /
+     *  `"none"`. CandleChart defaults to `"none"`. */
+    crosshairMarker?: CrosshairMarker;
+    /** Last-price horizontal reference line style. Default `"solid"`. */
+    lastPriceLine?: LastPriceLineStyle;
+    /** Show the last price as a pill on the y-axis. Default `true`. */
+    lastPriceLabel?: boolean;
+    /** Visible-range high/low marker mode: `"lines+labels"` (default),
+     *  `"labels"`, `"off"`. */
+    highLowMarkers?: HighLowMarkers;
+    /** Chart width in CSS pixels. Default 800. */
+    width?: number;
+    /** Chart height in CSS pixels. Default 400 (taller than LineChart
+     *  to accommodate the volume sub-pane). */
+    height?: number;
+    /** Color theme - `"light"`, `"dark"`, or `"inherit"`. */
+    theme?: ThemeInput;
+    /** Palette name (`"Monochrome"`, `"Classic"`, etc.). */
+    palette?: string;
+    /** `"Fill"` (default) = solid body fills; `"Outline"` = colored
+     *  border + translucent body fill. */
+    visualStyle?: "Fill" | "Outline";
+    /** In Outline mode, the fill color inside the outlined body. */
+    outlineFillColor?: "auto" | string;
+    /** In Outline mode, alpha of the outline body fill (0–100). */
+    outlineFillOpacity?: number;
+    /** Body corner radius in CSS px. Default 3. */
+    cornerRadius?: number;
+    /** Body border width in CSS px. Default 1.4. */
+    borderWidth?: number;
+    /** Cap the DPR (1–2 typical). */
+    pixelDensityCap?: number;
+    /** Skip cosmetic features for low-end devices. */
+    fastMode?: boolean;
+    /** Force sparkline mode (minimal axis-less render). */
+    sparkline?: boolean;
+    /** Override the auto-generated `aria-label`. */
+    ariaLabel?: string;
+    /** Toggle axis tick labels + spine. Default `true`. */
+    axisVisible?: boolean;
+    /** `"left"` or `"right"`. Default `"right"` for candles. */
+    yAxisPosition?: YAxisPosition;
+    /** `"bottom"` (default) or `"top"`. */
+    xAxisPosition?: XAxisPosition;
+    /** Fractional padding above/below the y-data range. Default 0.05. */
+    yAxisPadding?: number;
+    /** Toggle gridlines. */
+    gridVisible?: boolean;
+    /** Gridline style. */
+    gridStyle?: GridStyle;
+    /** Gridline density. */
+    gridDensity?: "sparse" | "normal" | "dense";
+    /** Use accent tint for axis + grid colors. */
+    accents?: boolean;
+    /** Locale code (e.g. `"USA"`). */
+    locale?: string;
+    /** IANA time zone. */
+    timeZone?: string;
+    /** Digit-grouping rule (`"thousands"` / `"lakh-crore"` / `"none"`). */
+    digitGrouping?: DigitGrouping;
+    /** Compact number abbreviation rule (e.g. `"short"` → `"1.2M"`). */
+    numberAbbreviation?: NumberAbbreviation;
+    /** Decimal-place rule for price labels. */
+    decimalPlaces?: DecimalPlaces;
+    /** ISO currency code (e.g. `"USD"`). */
+    currency?: string;
+    /** Currency display style. */
+    currencyDisplay?: CurrencyDisplay;
+    /** Percentage precision. */
+    percentPrecision?: PercentPrecision;
+    /** Date format rule. */
+    dateFormat?: DateFormat;
+    /** Time format rule. */
+    timeFormat?: TimeFormat;
+    /** Show the volume sub-pane. Requires `data.volumes` to be present.
+     *  Default `true` when volumes exist. */
+    volumeVisible?: boolean;
+    /** Volume placement: `"subpane"` (separate pane below price,
+     *  default) or `"overlay"` (transparent bars on the price pane). */
+    volumePlacement?: VolumePlacement;
+    /** Fraction of inner height given to the volume pane (0–1).
+     *  Default 0.25. */
+    volumeHeightRatio?: number;
+    /** Allow the user to drag the divider between price + volume panes. */
+    volumeResizable?: boolean;
+    /** Volume bar coloring: `"by-direction"` (matches candle direction,
+     *  default), `"single-color"`. */
+    volumeColoring?: VolumeColoring;
+    /** When `volumeColoring === "single-color"`, the bar color. */
+    volumeSingleColor?: "auto" | string;
+    /** Volume y-axis scale: `"linear"` (default) or `"log"`. */
+    volumeScale?: VolumeScale;
+    /** Sync the crosshair vertical line across price + volume +
+     *  indicator panes. Default `true`. */
+    crosshairPaneSync?: boolean;
+    /** Sub-pane indicators: RSI / MACD / Stochastic / ATR. Each becomes
+     *  its own pane below volume. */
+    indicators?: readonly IndicatorPaneSpec[];
+    /** Default line width for indicator lines. */
+    indicatorLineWidth?: number;
+    /** Default line style for indicator lines. */
+    indicatorLineStyle?: IndicatorLineStyle;
+    /** Default opacity for indicator lines (0–1). */
+    indicatorOpacity?: number;
+    /** Live-bar animation. */
+    liveBarIndicator?: LiveBarIndicator;
+    /** Connection-state badge: `"dot"` (default), `"pill"`, `"off"`.
+     *  Renders as an HTML overlay above the chart's plot area. */
+    connectionIndicator?: ConnectionIndicator;
+    /** Visual treatment for stale state. */
+    staleVisualization?: StaleVisualization;
+    /** Auto-stale timeout in ms. Default 5000. */
+    staleThreshold?: number;
+    /** Unix-ms of the latest accepted tick. */
+    liveSince?: number;
+    /** Host-asserted connection state. */
+    connectionState?: LiveState;
+    /** Anchor corner for the badge + legend overlay. */
+    legendPosition?: LegendPosition;
+    /** Host-forced reduced-motion override. */
+    reducedMotion?: boolean;
+    /** Animation when new bars first appear. */
+    barEntryAnimation?: BarEntryAnimation;
+    /** Animation when the live bar updates. */
+    barUpdateAnimation?: BarUpdateAnimation;
+    /** Crosshair fade-in duration (ms) on hover-enter. */
+    crosshairFadeDuration?: number;
+    /** Tooltip fade-in duration (ms). */
+    tooltipFadeDuration?: number;
+    /** Smooth wheel-zoom interpolation. */
+    panZoomSmoothing?: boolean;
+    /** Cross-fade transition when the theme changes. */
+    themeSwitchTransition?: ThemeSwitchTransition;
+    /** Drawing tool annotations (trendlines, fib, horizontal lines, etc.).
+     *  Host-controlled array - push new drawings via `onDrawingsChange`. */
+    drawings?: readonly DrawingT[];
+    /** Default stroke color for new drawings. */
+    drawingDefaultColor?: "auto" | string;
+    /** Default stroke width for new drawings. */
+    drawingDefaultLineWidth?: number;
+    /** Default stroke style for new drawings. */
+    drawingDefaultLineStyle?: "solid" | "dashed" | "dotted";
+    /** Default fill opacity for filled drawings. */
+    drawingFillOpacity?: number;
+    /** When to show resize handles: `"always"`, `"on-select"` (default),
+     *  `"on-hover"`. */
+    drawingHandlesMode?: "always" | "on-select" | "on-hover";
+    /** Controlled-mode: id of the currently selected drawing. */
+    selectedDrawingId?: string;
+    /** Whitelist of drawing tool types the user can create. */
+    enabledTools?: readonly import('../domain').DrawingType[];
+    /** Snap mode for drawing tool placement. */
+    drawingSnap?: "free" | "x-axis" | "data";
+    /** Delete the selected drawing when the user presses Esc. */
+    drawingDeleteOnEsc?: boolean;
+    /** Fires when the user adds, modifies, or removes a drawing. */
+    onDrawingsChange?: (next: readonly DrawingT[]) => void;
+    /** Fires when the selected drawing changes. */
+    onDrawingSelected?: (id: string | undefined) => void;
+    /** Signal markers (buy/sell arrows + confidence). */
+    signals?: readonly SignalMarker[];
+    /** Signal marker visualization mode. */
+    signalMarkers?: SignalMarkerMode;
+    /** Order markers (open/active orders with entry/SL/TP). */
+    orders?: readonly OrderMarker[];
+    /** Order marker visualization mode. */
+    orderMarkers?: OrderMarkerMode;
+    /** Singleton position marker (current open position). */
+    position?: PositionMarker;
+    /** Position marker visualization mode. */
+    positionMarker?: PositionMarkerMode;
+    /** Event markers (earnings, dividends, splits, news). */
+    events?: readonly EventMarker[];
+    /** Event marker visualization mode. */
+    eventMarkers?: EventMarkerMode;
+    /** Comparison series rendered as a normalized line overlay on the
+     *  price pane. */
+    compareData?: {
+        times: Float64Array;
+        closes: Float64Array;
+    };
+    /** Comparison rendering mode. */
+    symbolComparison?: "off" | "normalized-line";
+    /** Optional watermark - symbol text, symbol + exchange, or an image. */
+    watermark?: "off" | "symbol" | "symbol + exchange" | {
+        image: string;
+    };
+    /** Symbol ticker (e.g. `"AAPL"`) for watermark + tooltip header. */
+    symbol?: string;
+    /** Exchange code (e.g. `"NYSE"`) for watermark + tooltip header. */
+    exchange?: string;
+    /** Color-blind augmentation: `"arrows"` adds direction arrows to
+     *  bar bodies for users who can't distinguish red/green. */
+    colorBlindIndicators?: "off" | "arrows";
+    /** Direction-colored aura on candle bodies. */
+    glow?: import('../personalization/axes/glow').GlowInput;
+    /** Glow color. */
+    glowColor?: import('../personalization/axes/glow').GlowColorInput;
+    /** Pattern fills. */
+    pattern?: import('../personalization/axes/pattern').PatternInput;
+    patternScale?: number;
+    patternColor?: import('../personalization/axes/pattern').PatternColorInput;
+}
+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 EMPTY_DRAWINGS: readonly DrawingT[];
+export declare const EMPTY_SIGNALS: readonly SignalMarker[];
+export declare const EMPTY_ORDERS: readonly OrderMarker[];
+export declare const EMPTY_EVENTS: readonly EventMarker[];
+/** Watermark image cache. Decoded `Image` instances keyed
+ *  by URL / data-URI so repeated paints reuse the already-decoded
+ *  bitmap (object pooling, asynchronous render).
+ *  When the source is new and still loading, returns `null`; the
+ *  on-load callback bumps the chart's `watermarkVersion` to trigger a
+ *  redraw once the bitmap is ready. */
+export declare const _watermarkCache: Map<string, HTMLImageElement | "loading">;
+export declare const _watermarkSubscribers: Set<() => void>;
+export declare function getOrLoadWatermarkImage(src: string): HTMLImageElement | null;
+export declare const STALE_KEYFRAMES_ID = "tickyr-stale-keyframes";
+export declare function ensureStaleKeyframes(): void;
+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 declare const DEFAULT_BODY_WIDTH_RATIO = 0.7;
+export declare const DEFAULT_WICK_WIDTH = 1.4;
+export declare const DEFAULT_DOJI_MIN_BODY_PX = 1.5;
+export declare const SPARKLINE_THRESHOLD_PX = 150;
+export declare const DEFAULT_VOLUME_HEIGHT_RATIO = 0.25;
+export declare const PANE_DIVIDER_PX = 4;
+export declare const PANE_DRAG_HANDLE_PX = 5;
+export declare const VOLUME_OVERLAY_ALPHA = 0.4;
+export declare const DEFAULT_INDICATOR_HEIGHT_RATIO = 0.15;
+export declare const DEFAULT_INDICATOR_LINE_WIDTH = 1.5;
+export declare const DEFAULT_INDICATOR_LINE_STYLE: IndicatorLineStyle;
+export declare const DEFAULT_INDICATOR_OPACITY = 0.85;
+/** Indicator compute result - per-bar SoA arrays returned by the
+ *  engine for each indicator type. NaN values during the warmup period
+ *  are skipped by the line-draw primitive. */
+export type IndicatorComputeResult = {
+    type: "rsi";
+    spec: ResolvedRsiSpec;
+    values: Float64Array;
+} | {
+    type: "atr";
+    spec: ResolvedAtrSpec;
+    values: Float64Array;
+} | {
+    type: "macd";
+    spec: ResolvedMacdSpec;
+    macd: Float64Array;
+    signal: Float64Array;
+    histogram: Float64Array;
+} | {
+    type: "stochastic";
+    spec: ResolvedStochasticSpec;
+    k: Float64Array;
+    d: Float64Array;
+};
+/** Per-indicator pane layout - pixel rect + the y-scale that maps the
+ *  indicator's value range into that rect. For RSI / Stochastic this
+ *  is fixed [0, 100]; for MACD it's centered on 0; for ATR it's the
+ *  visible-window data range. */
+export interface IndicatorPaneLayout {
+    readonly result: IndicatorComputeResult;
+    readonly top: number;
+    readonly bottom: number;
+    readonly height: number;
+    readonly yScale: LinearScale;
+    readonly dividerY: number;
+}
+/** Pointer-driven hover state. Pins to the candle's slot center (x) and
+ *  to the close price (y) so the snap marker reads naturally for OHLC
+ *  data. `pane` indicates which pane the cursor is over - drives:
+ *    - per-pane crosshair clipping (when `crosshairPaneSync: false`)
+ *    - which tooltip renders (OHLC vs volume) on hover. */
+export interface HoverState {
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly snapX: number;
+    readonly snapY: number;
+    readonly idx: number;
+    readonly t: number;
+    readonly o: number;
+    readonly h: number;
+    readonly l: number;
+    readonly c: number;
+    readonly v: number;
+    readonly direction: CandleDirection;
+    readonly pane: "price" | "volume";
+}
+export interface DynamicCfg {
+    readonly crosshairVisible: boolean;
+    readonly crosshairLineStyle: GridStyle;
+    readonly crosshairMarker: CrosshairMarker;
+    /** When `true`, vertical crosshair spans
+     *  both price + volume panes; otherwise it stays within the price
+     *  pane only. */
+    readonly crosshairPaneSync: boolean;
+}
+export interface PillBox {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface ExtremeMarkerState {
+    readonly high: {
+        idx: number;
+        t: number;
+        price: number;
+        pillBox: PillBox | null;
+    };
+    readonly low: {
+        idx: number;
+        t: number;
+        price: number;
+        pillBox: PillBox | null;
+    };
+}
+export interface ExtremeHoverState {
+    readonly kind: "high" | "low";
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly idx: number;
+    readonly t: number;
+    readonly price: number;
+}
+export interface ChartHandle {
+    readonly dynamicCtx: CanvasRenderingContext2D | null;
+    readonly layout: ChartLayout;
+    readonly crosshairLineColor: string;
+    readonly crosshairMarkerFill: string;
+    readonly crosshairMarkerStroke: string;
+    /** Extreme-marker state from the latest static-layer paint. `null`
+     *  when `highLowMarkers === 'off'`. */
+    readonly extremes: ExtremeMarkerState | null;
+    /** Last bar's center x in CSS px (for live-bar indicator). */
+    readonly lastX: number;
+    /** Last bar's close y in CSS px. */
+    readonly lastY: number;
+    /** Last candle's resolved body top y (after doji floor). */
+    readonly lastBodyTop: number;
+    /** Last candle's resolved body bottom y. */
+    readonly lastBodyBottom: number;
+    /** Last candle's wick top (= y of `high`). */
+    readonly lastWickTop: number;
+    /** Last candle's wick bottom (= y of `low`). */
+    readonly lastWickBottom: number;
+    /** Half body width in CSS px (= bodyExtent / 2). */
+    readonly lastHalfBodyW: number;
+    /** Resolved candle body cornerRadius in CSS px (matches the static
+     *  layer's body roundness - the live-bar dotted-border treatment
+     *  uses this so its stroke traces the candle's actual silhouette. */
+    readonly lastCornerRadius: number;
+    /** True when last candle is a doji (|O−C| < `dojiMinBodyHeight`). */
+    readonly lastIsDoji: boolean;
+    /** True when last close ≥ last open. */
+    readonly lastIsUp: boolean;
+    readonly directionColor: string;
+    readonly accentColor: string;
+    readonly bgColor: string;
+    readonly textColor: string;
+    readonly liveStateColor: string;
+    readonly staleStateColor: string;
+    readonly disconnectedStateColor: string;
+    /** Resolved Personalization snapshot (so the dynamic-layer draw can
+     *  read liveBarIndicator / connectionIndicator / visualStyle without
+     *  re-resolving). */
+    readonly personalization: Personalization;
+}
+export interface LiveStateInputs {
+    readonly liveSince: number | undefined;
+    readonly connectionState: LiveState | undefined;
+    readonly staleThreshold: number;
+}
+export interface ChartLayout {
+    innerLeft: number;
+    innerRight: number;
+    innerTop: number;
+    innerBottom: number;
+    /** Maps OHLC value → y pixel within the PRICE pane. Inverted:
+     *  rangeStart = priceBottom, rangeEnd = priceTop (= innerTop). When
+     *  no volume sub-pane is active, priceBottom === innerBottom. */
+    yScale: LinearScale;
+    /** Maps unix-ms time → x pixel. Range = [innerLeft + halfSlot,
+     *  innerRight - halfSlot] so first/last bar centers sit comfortably
+     *  inside the axis spine. Shared between price and volume panes. */
+    xScale: LinearScale;
+    yTicks: readonly NiceTick[];
+    xTicks: readonly XAxisTick[];
+    startMs: number;
+    endMs: number;
+    halfSlot: number;
+    viewport: Viewport;
+    /** Volume sub-pane geometry. `null` when volumes are absent or
+     *  `volumeVisible === false` or `volumePlacement === 'overlay'`. */
+    volumePane: {
+        readonly top: number;
+        readonly bottom: number;
+        readonly height: number;
+        /** Maps volume value → y pixel within the volume pane (inverted:
+         *  rangeStart = bottom, rangeEnd = top). */
+        readonly yScale: LinearScale | LogScale;
+        /** Y of the divider line between price + volume panes. */
+        readonly dividerY: number;
+    } | null;
+    /** When `volumePlacement === 'overlay'`, the bars draw inside the
+     *  price pane at this y-range. `null` when not in overlay mode. */
+    volumeOverlay: {
+        readonly top: number;
+        readonly bottom: number;
+        readonly yScale: LinearScale | LogScale;
+    } | null;
+    /** Indicator sub-panes. Empty when no indicators are
+     *  configured. Order matches `props.indicators`. */
+    indicatorPanes: readonly IndicatorPaneLayout[];
+}
+/** Source-of-data resolver. For Solid + OHLC-bars this is the raw
+ *  CandleSeries arrays; for Heikin-Ashi it's the transformed arrays
+ *  (cached per series.revisionId). Volumes pass through unchanged
+ *  regardless of `candleType` - the HA transform smooths OHLC, not
+ *  per-bar volume. */
+export interface ResolvedSeriesArrays {
+    readonly times: Float64Array;
+    readonly opens: Float64Array;
+    readonly highs: Float64Array;
+    readonly lows: Float64Array;
+    readonly closes: Float64Array;
+    readonly volumes: Float64Array | null;
+    readonly length: number;
+}
+export declare function resolveSeriesArrays(series: CandleSeries, candleType: CandleType): ResolvedSeriesArrays;
+export declare function computeYDomain(arr: ResolvedSeriesArrays, padding: number): {
+    min: number;
+    max: number;
+};
+export declare function computeLayout(opts: {
+    arr: ResolvedSeriesArrays;
+    viewport: Viewport;
+    yAxisPosition: YAxisPosition;
+    xAxisPosition: XAxisPosition;
+    yAxisPadding: number;
+    gridDensity: "sparse" | "normal" | "dense";
+    axisVisible: boolean;
+    formatter: ChartFormatter;
+    /** When `true` AND `arr.volumes !== null` AND placement === 'subpane',
+     *  the inner area is split into price + volume panes. */
+    volumeSubpane: boolean;
+    /** When `true` AND `arr.volumes !== null` AND placement === 'overlay',
+     *  bars draw inside the price pane's bottom region. */
+    volumeOverlay: boolean;
+    /** Initial (or current session-state) ratio for the volume sub-pane. */
+    volumeHeightRatio: number;
+    /** Y-scale type for volume bars. */
+    volumeScale: VolumeScale;
+    /** Indicator compute results, one per `props.indicators[i]`. Each
+     *  becomes its own sub-pane below price + volume. */
+    indicatorResults: readonly IndicatorComputeResult[];
+    /** Extra top reserve (CSS px) for HTML overlays - connection
+     *  indicator badge, legend. Pushes `innerTop` down so the chart's
+     *  drawing area starts BELOW the overlay band, never overlapping. */
+    topBandReserve?: number;
+}): ChartLayout;
+export declare function drawCandleChartGrid(args: {
+    ctx: CanvasRenderingContext2D;
+    layout: ChartLayout;
+    color: string;
+    width: number;
+    style: GridStyle;
+}): void;
+export declare function drawCandleChartAxes(args: {
+    ctx: CanvasRenderingContext2D;
+    layout: ChartLayout;
+    yAxisPosition: YAxisPosition;
+    xAxisPosition: XAxisPosition;
+    spineColor: string;
+    textColor: string;
+    formatter: ChartFormatter;
+}): void;
+export declare function drawFullCandleChart(args: {
+    ctx: CanvasRenderingContext2D;
+    arr: ResolvedSeriesArrays;
+    layout: ChartLayout;
+    personalization: Personalization;
+    candleType: CandleType;
+    bodyWidthRatio: number;
+    wickWidth: number;
+    wickColor: WickColor;
+    dojiMinBodyHeight: number;
+    cornerRadius: number;
+    borderWidth: number;
+    yAxisPosition: YAxisPosition;
+    xAxisPosition: XAxisPosition;
+    gridVisible: boolean;
+    gridStyle: GridStyle;
+    axisVisible: boolean;
+    accents: boolean;
+    lastPriceLine: LastPriceLineStyle;
+    lastPriceLabel: boolean;
+    highLowMarkers: HighLowMarkers;
+    formatter: ChartFormatter;
+    chartBgColor: string;
+    /** Volume coloring mode. */
+    volumeColoring: VolumeColoringInternal;
+    volumeSingleColor: "auto" | string;
+    /** Entry-animation preset + linear progress in [0, 1]. */
+    entryPreset: BarEntryAnimation;
+    entryProgress: number;
+    /** Last-bar update animation preset + progress + direction sign. */
+    updatePreset: BarUpdateAnimation;
+    updateProgress: number;
+    updateDirSign: 1 | -1 | 0;
+    drawings: readonly DrawingT[];
+    selectedDrawingId: string | undefined;
+    drawingDefaultColor: string;
+    drawingDefaultLineWidth: number;
+    drawingDefaultLineStyle: "solid" | "dashed" | "dotted";
+    drawingFillOpacity: number;
+    signals: readonly SignalMarker[];
+    signalMarkersMode: SignalMarkerMode;
+    orders: readonly OrderMarker[];
+    orderMarkersMode: OrderMarkerMode;
+    position: PositionMarker | undefined;
+    positionMarkerMode: PositionMarkerMode;
+    events: readonly EventMarker[];
+    eventMarkersMode: EventMarkerMode;
+    /** VWAP overlay (per-bar values from engine). Renders as a line on
+     *  the price pane when `values !== null`. */
+    vwapOverlay: {
+        readonly values: Float64Array;
+        readonly color: string;
+        readonly lineWidth: number;
+    } | null;
+    compareData: {
+        times: Float64Array;
+        closes: Float64Array;
+    } | undefined;
+    symbolComparisonMode: "off" | "normalized-line";
+    watermark: "off" | "symbol" | "symbol + exchange" | {
+        image: string;
+    };
+    symbol: string | undefined;
+    exchange: string | undefined;
+    colorBlindIndicators: "off" | "arrows";
+    /** Section gating for offscreen caching.
+     *  - `"all"` (default): everything (current full-paint behavior).
+     *  - `"bg"`: clear + grid + axes + volume sub-pane + indicator sub-
+     *    panes. Cached once to an offscreen canvas.
+     *  - `"bars"`: candle bodies/wicks + last-bar update overlays. The
+     *    only sections that animate; called per rAF frame.
+     *  - `"fg"`: drawings + watermark + comparison overlay + markers +
+     *    last-price + extremes. Cached once to an offscreen canvas.
+     *
+     *  Per-frame the chart pastes the cached BG, paints just the bars,
+     *  then pastes the cached FG. ~20 fillText + axis paths per-frame
+     *  → 1 drawImage. */
+    phase?: "all" | "bg" | "bars" | "fg";
+}): {
+    extremes: ExtremeMarkerState | null;
+};
+export declare function drawCandleChartDynamicLayer(h: ChartHandle, hover: HoverState | null, cfg: DynamicCfg, now: number, reducedMotion: boolean, liveStateInputs: LiveStateInputs, crosshairAlpha?: number, dirtyRects?: readonly Rect[] | null, dirtyCount?: number): void;
+export declare function defaultAriaLabel(series: CandleSeries, candleType: CandleType): string;