@abdullahjaswal/tickyr-charts-solid 0.1.0

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

@@ -0,0 +1,82 @@
+import { Personalization, ThemeInput, VisualStyle, Theme, BinAlgorithm, YAxisMode, ResolvedHistogramOverlay, ChartFormatter } from '../personalization';
+import { HoverState, HistogramChartBaseProps, HistogramChartTooltipProps, HistogramSeries } from './histogram-chart-helpers';
+export interface HistogramChartProviderSnapshot {
+    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 HistogramChartRenderContext {
+    personalization: Personalization;
+    formatter: ChartFormatter;
+    resolvedLocaleBase: string;
+    resolvedTimeZone: string | undefined;
+    series: HistogramSeries;
+    binCount: number;
+    yAxisMode: YAxisMode;
+    binAlgorithm: BinAlgorithm;
+    resolvedOverlay: ResolvedHistogramOverlay | null;
+    ariaLabel: string;
+    isSparkline: boolean;
+    cssWidth: number;
+    cssHeight: number;
+}
+export interface HistogramChartControllerCallbacks {
+    onContextChange(ctx: HistogramChartRenderContext): void;
+    onHoverChange(hover: HoverState | null): void;
+}
+export interface HistogramChartControllerProps extends HistogramChartBaseProps {
+    tooltip?: undefined | false | ((p: HistogramChartTooltipProps) => unknown);
+}
+export interface HistogramChartControllerMountOptions extends HistogramChartControllerCallbacks {
+    container?: HTMLElement | null;
+    staticCanvas: HTMLCanvasElement;
+    dynamicCanvas: HTMLCanvasElement | null;
+    initialProps: HistogramChartControllerProps;
+    initialProvider: HistogramChartProviderSnapshot;
+}
+export declare class HistogramChartController {
+    private staticCanvas;
+    private dynamicCanvas;
+    private callbacks;
+    private props;
+    private providerCtx;
+    private handle;
+    private hoverState;
+    private dynCfg;
+    private series;
+    private personalization;
+    private resolvedLocale;
+    private formatter;
+    private binAlgorithm;
+    private yAxisMode;
+    private resolvedOverlay;
+    private isSparkline;
+    private edges;
+    private counts;
+    private yValues;
+    private binCount;
+    private totalCount;
+    private normalMean;
+    private normalStd;
+    private staticDrawAbort;
+    private disposed;
+    private visGate;
+    constructor(opts: HistogramChartControllerMountOptions);
+    update(props: HistogramChartControllerProps, providerCtx: HistogramChartProviderSnapshot): void;
+    handlePointerMove(e: PointerEvent): void;
+    handlePointerLeave(): void;
+    dispose(): void;
+    private setHover;
+    private resolveDerived;
+    private applyDynamicCfgFromProps;
+    private runStaticDraw;
+}

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

@@ -0,0 +1,199 @@
+import { Personalization, ThemeInput, DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat, LegendPosition, LegendVisibility, BinAlgorithm, YAxisMode, HistogramOverlayInput, ResolvedHistogramOverlay, ChartFormatter } from '../personalization';
+import { Viewport } from '../viewport/viewport-sizer';
+import { LinearScale } from '../viewport/scales/linear';
+import { NiceTick } from '../viewport/nice-ticks';
+import { YAxisPosition, XAxisPosition } from '../rendering/draw/axis';
+import { GridStyle } from '../rendering/draw/grid';
+import { CrosshairMarker } from '../rendering/draw/crosshair';
+export type HistogramSeriesInput = {
+    readonly values: Float64Array;
+} | {
+    readonly values: readonly number[];
+};
+export declare class HistogramSeries {
+    #private;
+    readonly values: Float64Array;
+    readonly length: number;
+    constructor(values: Float64Array);
+    get revisionId(): number;
+    bumpRevision(): number;
+}
+export declare function ingestHistogramSeries(input: HistogramSeriesInput): HistogramSeries;
+export interface HistogramChartTooltipProps {
+    /** Bin index (0-based). */
+    readonly binIdx: number;
+    /** Lower edge of the bin (data value). */
+    readonly binStart: number;
+    /** Upper edge of the bin (data value). */
+    readonly binEnd: number;
+    /** Raw count in this bin. */
+    readonly count: number;
+    /** Y-value rendered (frequency / density / cumulative). */
+    readonly value: number;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: import('../personalization').Theme;
+    readonly palette: import('../personalization').Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+export interface HistogramChartBaseProps {
+    /** Distribution data - raw values that will be binned by the
+     *  configured algorithm. See `HistogramSeriesInput`. */
+    data?: HistogramSeriesInput;
+    /** Default 'freedman-diaconis'. */
+    binAlgorithm?: BinAlgorithm;
+    /** Used when `binAlgorithm: 'fixed'`. */
+    binCount?: number;
+    /** `'auto'` → data min. */
+    binStart?: number | "auto";
+    /** `'auto'` → data max. */
+    binEnd?: number | "auto";
+    /** Default 'frequency'. */
+    yAxis?: YAxisMode;
+    /** Default 1.0 (touching bars). */
+    barWidthRatio?: number;
+    /** Default false. */
+    overlay?: HistogramOverlayInput;
+    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;
+    sparkline?: boolean;
+    ariaLabel?: string;
+    axisVisible?: boolean;
+    yAxisPosition?: YAxisPosition;
+    xAxisPosition?: XAxisPosition;
+    yAxisPadding?: number;
+    gridVisible?: boolean;
+    gridStyle?: GridStyle;
+    gridDensity?: "sparse" | "normal" | "dense";
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    cornerRadius?: number;
+    borderWidth?: number;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+export declare const DEFAULT_FONT = "12px system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif";
+export declare const DEFAULT_AXIS_FONT_SIZE = 11;
+export declare const 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 SPARKLINE_THRESHOLD_PX = 150;
+export declare const DEFAULT_BAR_WIDTH_RATIO = 1;
+export interface HoverState {
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly snapX: number;
+    readonly snapY: number;
+    readonly binIdx: number;
+    readonly binStart: number;
+    readonly binEnd: number;
+    readonly count: number;
+    readonly value: number;
+}
+export interface DynamicCfg {
+    readonly crosshairVisible: boolean;
+    readonly crosshairLineStyle: GridStyle;
+    readonly crosshairMarker: CrosshairMarker;
+}
+export interface ChartLayout {
+    innerLeft: number;
+    innerRight: number;
+    innerTop: number;
+    innerBottom: number;
+    /** Maps a data value (numeric) to an x-pixel. */
+    xScale: LinearScale;
+    /** Maps a y-value (frequency/density/cumulative) to a y-pixel. */
+    yScale: LinearScale;
+    /** Bin edges in data-space - `length === binCount + 1`. */
+    edges: Float64Array;
+    /** Per-bin y-values (frequency/density/cumulative). */
+    yValues: Float64Array;
+    /** Raw counts (for tooltip display). */
+    counts: Uint32Array;
+    /** Numeric ticks for the y-axis. */
+    yTicks: readonly NiceTick[];
+    /** Numeric ticks for the x-axis. */
+    xTicks: readonly NiceTick[];
+    viewport: Viewport;
+}
+export interface ChartHandle {
+    readonly dynamicCtx: CanvasRenderingContext2D | null;
+    readonly layout: ChartLayout;
+    readonly crosshairLineColor: string;
+    readonly crosshairMarkerFill: string;
+    readonly crosshairMarkerStroke: string;
+    readonly fillColor: string;
+}
+export declare function computeLayout(opts: {
+    edges: Float64Array;
+    yValues: Float64Array;
+    counts: Uint32Array;
+    viewport: Viewport;
+    yAxisPosition: YAxisPosition;
+    xAxisPosition: XAxisPosition;
+    yAxisPadding: number;
+    gridDensity: "sparse" | "normal" | "dense";
+    axisVisible: boolean;
+    formatter: ChartFormatter;
+}): ChartLayout;
+export declare function defaultAriaLabel(series: HistogramSeries, binCount: number): string;
+export interface DrawFullHistogramArgs {
+    ctx: CanvasRenderingContext2D;
+    personalization: Personalization;
+    accents: boolean;
+    layout: ChartLayout;
+    axisVisible: boolean;
+    gridVisible: boolean;
+    gridStyle: GridStyle;
+    yAxisPosition: YAxisPosition;
+    xAxisPosition: XAxisPosition;
+    cornerRadius: number;
+    borderWidth: number;
+    barWidthRatio: number;
+    overlay: ResolvedHistogramOverlay | null;
+    /** When overlay is 'normal' - pre-fitted distribution. */
+    normalMean: number;
+    normalStd: number;
+    /** Total count across all bins (for normal overlay scaling). */
+    totalCount: number;
+    yAxisMode: YAxisMode;
+}
+export declare function drawFullHistogramChart(args: DrawFullHistogramArgs): void;
+export declare function drawHistogramDynamicLayer(handle: ChartHandle, hover: HoverState | null, cfg: DynamicCfg): void;
+export declare function findBinAtX(edges: Float64Array, binCount: number, dataX: number): number;

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

@@ -0,0 +1,154 @@
+import { Personalization, ThemeInput, VisualStyle, Theme, BoxSizingInput, TimeOffSource, KagiThicknessRule, ChartFormatter, DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat } from '../personalization';
+import { YAxisPosition, XAxisPosition } from '../rendering/draw/axis';
+import { GridStyle } from '../rendering/draw/grid';
+import { CrosshairMarker } from '../rendering/draw/crosshair';
+import { CandleSeriesInput } from '../domain';
+import { KagiLegs } from './time-off-algorithms';
+export interface KagiChartTooltipProps {
+    readonly idx: number;
+    readonly direction: 1 | -1;
+    readonly thick: boolean;
+    readonly startPrice: number;
+    readonly endPrice: number;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: import('../personalization').Theme;
+    readonly palette: import('../personalization').Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+export interface KagiChartBaseProps {
+    /** Required OHLC bars - Kagi filters out time and tracks direction
+     *  flips by reversal threshold. */
+    data?: CandleSeriesInput;
+    /** Price-distance required to reverse direction. `"auto"` =
+     *  ATR-derived; or a fixed value. */
+    reversalThreshold?: BoxSizingInput;
+    /** Rule for thick/thin line transitions (yang vs yin). */
+    thicknessRule?: KagiThicknessRule;
+    /** Stroke width for thick (uptrend) lines. */
+    thickLineWidth?: number;
+    /** Stroke width for thin (downtrend) lines. */
+    thinLineWidth?: number;
+    /** Source field for price comparisons. */
+    source?: TimeOffSource;
+    /** Toggle crosshair on hover. */
+    crosshairVisible?: boolean;
+    /** Crosshair line style. */
+    crosshairLineStyle?: GridStyle;
+    /** Snap-marker shape. */
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: import('../personalization/axes/glow').GlowInput;
+    glowColor?: import('../personalization/axes/glow').GlowColorInput;
+    /** Pattern fills. */
+    pattern?: import('../personalization/axes/pattern').PatternInput;
+    patternScale?: number;
+    patternColor?: import('../personalization/axes/pattern').PatternColorInput;
+    ariaLabel?: string;
+    axisVisible?: boolean;
+    yAxisPosition?: YAxisPosition;
+    xAxisPosition?: XAxisPosition;
+    yAxisPadding?: number;
+    gridVisible?: boolean;
+    gridStyle?: GridStyle;
+    gridDensity?: "sparse" | "normal" | "dense";
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+export interface KagiChartProviderSnapshot {
+    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 KagiChartRenderContext {
+    personalization: Personalization;
+    formatter: ChartFormatter;
+    resolvedLocaleBase: string;
+    resolvedTimeZone: string | undefined;
+    legs: KagiLegs;
+    ariaLabel: string;
+    cssWidth: number;
+    cssHeight: number;
+}
+export interface HoverState {
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly idx: number;
+    readonly direction: 1 | -1;
+    readonly thick: boolean;
+    readonly startPrice: number;
+    readonly endPrice: number;
+}
+export interface KagiChartControllerProps extends KagiChartBaseProps {
+    tooltip?: undefined | false | ((p: KagiChartTooltipProps) => unknown);
+}
+export interface KagiChartControllerCallbacks {
+    onContextChange(ctx: KagiChartRenderContext): void;
+    onHoverChange(hover: HoverState | null): void;
+}
+export interface KagiChartControllerMountOptions extends KagiChartControllerCallbacks {
+    container?: HTMLElement | null;
+    staticCanvas: HTMLCanvasElement;
+    dynamicCanvas: HTMLCanvasElement | null;
+    initialProps: KagiChartControllerProps;
+    initialProvider: KagiChartProviderSnapshot;
+}
+export declare class KagiChartController {
+    private staticCanvas;
+    private dynamicCanvas;
+    private callbacks;
+    private props;
+    private providerCtx;
+    private handle;
+    private dynCfg;
+    private legs;
+    private personalization;
+    private resolvedLocale;
+    private formatter;
+    private thicknessRule;
+    private thickLineWidth;
+    private thinLineWidth;
+    private staticDrawAbort;
+    private disposed;
+    private visGate;
+    constructor(opts: KagiChartControllerMountOptions);
+    update(props: KagiChartControllerProps, providerCtx: KagiChartProviderSnapshot): void;
+    handlePointerMove(e: PointerEvent): void;
+    handlePointerLeave(): void;
+    dispose(): void;
+    private setHover;
+    private resolveDerived;
+    private applyDynamicCfgFromProps;
+    private runStaticDraw;
+}

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

@@ -0,0 +1,209 @@
+import { LineSeries, LiveState } from '../domain';
+import { Personalization, ChartFormatter, ConnectionIndicator } from '../personalization';
+import { StackingLayout } from '../rendering/stacked-layout';
+import { ExtremeHoverState, HoverState, LineChartBaseProps, ResolvedIndicator, SecondarySeriesDraw, ConnectionIndicatorRenderProps, StaleBannerRenderProps, LineChartTooltipProps, ExtremeTooltipProps } from './line-chart-helpers';
+/** Controller-specific prop type. Extends the framework-agnostic
+ *  `LineChartBaseProps` (in `line-chart-helpers.ts`) with the four
+ *  render-prop fields whose return type is widened to `unknown` so both
+ *  the React adapter (returns `React.ReactNode`) and the Solid adapter
+ *  (returns `JSX.Element`) pass type-check via covariance. */
+export interface LineChartControllerProps extends LineChartBaseProps {
+    tooltip?: boolean | ((p: LineChartTooltipProps) => unknown);
+    extremeTooltip?: boolean | ((p: ExtremeTooltipProps) => unknown);
+    staleBanner?: boolean | ((p: StaleBannerRenderProps) => unknown);
+    connectionIndicator?: ConnectionIndicator | ((p: ConnectionIndicatorRenderProps) => unknown);
+}
+/** Provider snapshot the controller consumes. Mirrors `ChartsProviderValue`
+ *  (declared in src/react/charts-provider.tsx and src/solid/charts-provider.tsx)
+ *  but kept as a structural type so this file stays framework-agnostic. */
+export interface LineChartProviderSnapshot {
+    theme: import('../personalization').ThemeInput;
+    palette: string;
+    locale: string;
+    timeZone: string | undefined;
+    visualStyle: import('../personalization').VisualStyle;
+    outlineFillColor: "auto" | string;
+    outlineFillOpacity: number;
+    cornerRadius: number;
+    borderWidth: number;
+    accents: boolean;
+    osTheme: import('../personalization').Theme;
+    appTheme: import('../personalization').Theme;
+}
+/** Snapshot of derived state the adapter exposes to JSX.
+ *  Recomputed inside `update()` and pushed via `onContextChange`. */
+export interface LineChartRenderContext {
+    personalization: Personalization;
+    formatter: ChartFormatter;
+    resolvedLocaleBase: string;
+    resolvedTimeZone: string | undefined;
+    series: LineSeries;
+    secondarySeriesList: readonly SecondarySeriesDraw[];
+    stackedLayout: StackingLayout | null;
+    primaryColorOverride: string | undefined;
+    ariaLabel: string;
+    isSparkline: boolean;
+    cssWidth: number;
+    cssHeight: number;
+}
+export interface LineChartControllerCallbacks {
+    onContextChange(ctx: LineChartRenderContext): void;
+    onHoverChange(hover: HoverState | null): void;
+    onExtremeHoverChange(eh: ExtremeHoverState | null): void;
+    onLiveStateChange(s: LiveState): void;
+    onReducedMotionChange(v: boolean): void;
+    onResolvedIndicatorsChange(inds: readonly ResolvedIndicator[]): void;
+}
+export interface LineChartControllerMountOptions extends LineChartControllerCallbacks {
+    /** The chart's outer container DOM node. `null` in sparkline mode (only
+     *  the static canvas is mounted). */
+    container: HTMLDivElement | null;
+    staticCanvas: HTMLCanvasElement;
+    /** Dynamic-layer canvas. `null` in sparkline mode. */
+    dynamicCanvas: HTMLCanvasElement | null;
+    initialProps: LineChartControllerProps;
+    initialProvider: LineChartProviderSnapshot;
+}
+export declare class LineChartController {
+    private staticCanvas;
+    private dynamicCanvas;
+    private callbacks;
+    private props;
+    private providerCtx;
+    private handle;
+    private hoverState;
+    /** Latest extreme-pill hover; mirrored to the adapter via
+     *  `onExtremeHoverChange` for tooltip JSX. The controller keeps the
+     *  reference so future extreme-pill timing logic (e.g. auto-dismiss
+     *  on data update) has somewhere to read from. */
+    private extremeHoverState;
+    private dynCfg;
+    private liveStateInputs;
+    private reducedMotion;
+    private liveState;
+    private resolvedIndicators;
+    private series;
+    private historySeries;
+    private combinedSeries;
+    private liveTickTimes;
+    private liveTickValues;
+    private liveTickLength;
+    private liveTickCapacity;
+    /** Source-data identity tracked at last resolveDerived. When it
+     *  changes the live-tick ring is reset (host has provided a new
+     *  baseline; in-flight ticks predate it). */
+    private liveTickSourceId;
+    /** Coalesces back-to-back onTick calls in one rAF - only one static
+     *  draw per frame even if 30 ticks arrive in 16ms. */
+    private onTickRafId;
+    private personalization;
+    private resolvedLocale;
+    private formatter;
+    private secondarySeriesList;
+    private stackedLayout;
+    private primaryColorOverride;
+    private isSparkline;
+    /** Dirty-rect tracking for partial dynamic-layer repaints.
+     *  Crosshair / hover overlays disturb only thin
+     *  strips (V + H + small marker) - clipping to those gives a real
+     *  GPU-fill saving. Auto-disabled below `shouldUseDirtyRects`
+     *  threshold; force-disabled via `partialRepaints: false` prop. */
+    private dirtyRing;
+    /** Reused multi-rect scratch - `flushAll` populates this in-place. */
+    private dirtyScratch;
+    private useDirtyRects;
+    /** Previous hover snapshot - used to compute the "old crosshair" rect
+     *  on hover transitions so the leaving crosshair gets cleared too. */
+    private prevHoverSnapX;
+    private prevHoverSnapY;
+    private prevHoverActive;
+    /** Sparkline bitmap cache. For <150px containers,
+     *  rendering the curve costs more than blitting a cached bitmap. Cache
+     *  is keyed on every input that affects pixels - palette, theme, line
+     *  width / dash, curve type, viewport size, data revision. */
+    private sparklineCache;
+    private mqCleanup;
+    private staleTimeoutId;
+    private indicatorAbort;
+    /** 50ms trailing debounce for kickIndicatorCompute - rapid param
+     *  changes (e.g. dragging an indicator slider) coalesce into a single
+     *  recompute. */
+    private indicatorComputeDebounceId;
+    private rafId;
+    /** Visibility source - pauses the rAF loop when the chart is in a
+     *  hidden tab OR scrolled off-screen. */
+    private visibility;
+    private visibilityUnsubscribe;
+    /** Cancellation flag for the in-flight static-draw async work. Bumped
+     *  on every redraw + on dispose so any pending TimeAxis awaits short-
+     *  circuit before they touch a freed handle. */
+    private staticDrawAbort;
+    private taHandle;
+    /** True after `dispose()`. Subsequent calls become no-ops. */
+    private disposed;
+    constructor(opts: LineChartControllerMountOptions);
+    /** Adapter must call this whenever its props or its provider snapshot
+     *  changes. Idempotent for unchanged inputs. */
+    update(props: LineChartControllerProps, providerCtx: LineChartProviderSnapshot): void;
+    handlePointerMove(e: PointerEvent): void;
+    handlePointerLeave(): void;
+    /** Apply an externally-driven crosshair time (e.g. coming from a sibling
+     *  chart inside `<ChartGroup>` with `syncCrosshair: true`). Suppressed
+     *  when this chart already has a local hover (the user is hovering this
+     *  chart - its own hover is the source of truth). When `time` is null,
+     *  the synced crosshair is cleared. */
+    applyExternalCrosshair(time: number | null): void;
+    /** Imperative live-tick API. Primitive args
+     *  (no object literals, no per-call allocation in steady state once
+     *  the ring buffer has settled). Multiple ticks within one rAF
+     *  coalesce into a single static draw.
+     *
+     *  `_size` is accepted for API parity with CandleChart/streaming
+     *  consumers but is unused for line charts (line is value-over-time;
+     *  size doesn't affect the rendered geometry). */
+    onTick(time: number, price: number, _size?: number): void;
+    /** Internal: build a `LineSeries` that concatenates the host's
+     *  base data with the in-flight live ticks. Allocates one pair of
+     *  typed arrays per static draw - bounded by total tick count. */
+    private materializeWithLiveTicks;
+    dispose(): void;
+    private setHover;
+    private setExtremeHover;
+    /** Recompute series + personalization + formatter + secondary list +
+     *  stackedLayout + primaryColorOverride. Pushes a fresh
+     *  `LineChartRenderContext` to the adapter for JSX rendering. */
+    private resolveDerived;
+    private applyDynamicCfgFromProps;
+    private applyLiveStateInputsFromProps;
+    private setupReducedMotionWatcher;
+    private tearDownReducedMotionWatcher;
+    private kickStaleTimeout;
+    /** Debounced wrapper around `kickIndicatorCompute` - coalesces rapid
+     *  prop changes (e.g. an indicator slider being dragged) into a single
+     *  engine recompute after 50ms of quiet (coalesced compute on
+     *  rapid param changes). */
+    private kickIndicatorComputeDebounced;
+    private kickIndicatorCompute;
+    private kickRafLoop;
+    private tearDownRafLoop;
+    /** Push crosshair-overlay disturbance rects into the dirty ring for
+     *  this and the previous hover position. The rects must cover every
+     *  pixel that will be drawn (or was drawn last
+     *  frame) - V-strip (vertical line + marker), H-strip (horizontal
+     *  line), live-bar indicator region.
+     *
+     *  No-op when partial repaints are off - caller falls through to a
+     *  full-canvas clear in that case. */
+    private pushDynamicDirtyRects;
+    /** Wrap `drawDynamicLayer` with dirty-rect flushing when partial
+     *  repaints are active. Returns the call to make this a single line
+     *  at every existing call site. */
+    private repaintDynamicWith;
+    /** The static-draw orchestration. Mounts the static canvas, awaits the
+     *  engine TimeAxis, computes layout + colors, calls `drawFullLineChart`,
+     *  saves the resulting `ChartHandle`, paints the dynamic layer once. */
+    private runStaticDraw;
+}
+/** Re-export the underlying types so adapters can reference them
+ *  without dipping into `src/charts/line-chart-helpers`. */
+export type { HoverState, ExtremeHoverState, ResolvedIndicator, SecondarySeriesDraw, ChartHandle, ChartLayout, DynamicCfg, LiveStateInputs, LineChartBaseProps, } from './line-chart-helpers';