@abdullahjaswal/tickyr-charts-solid 0.1.0

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

@@ -0,0 +1,606 @@
+import { LineSeries, LineSeriesInput, LiveState } from '../domain';
+import { Personalization, LiveBarIndicator, ThemeInput, Theme, Palette, LegendPosition, LegendVisibility, StaleVisualization, DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat, ChartFormatter } from '../personalization';
+import { Viewport } from '../viewport/viewport-sizer';
+import { LinearScale } from '../viewport/scales/linear';
+import { NiceTick } from '../viewport/nice-ticks';
+import { YAxisPosition, XAxisPosition, XAxisTick } from '../rendering/draw/axis';
+import { GridStyle } from '../rendering/draw/grid';
+import { Rect } from '../rendering/dirty-rect-tracker';
+import { CrosshairMarker } from '../rendering/draw/crosshair';
+import { StackingLayout } from '../rendering/stacked-layout';
+import { LastPriceLineStyle } from '../rendering/draw/last-price';
+import { AreaBaseline } from '../personalization/axes/area-baseline';
+import { CurveType } from '../personalization/axes/curve-type';
+import { LineDash } from '../personalization/axes/line-dash';
+import { PointMarkers, ResolvedMarkerConfig } from '../personalization/axes/point-markers';
+import { TimeAxisHandle } from '../engine';
+import { CurveFactory } from 'd3-shape';
+export type CrosshairSnap = "free" | "x-axis" | "data";
+export type CrosshairMode = "follow" | "sticky";
+/** Per-series value at the hover-x. Every visible
+ *  series shows its value at the cursor in multi-series mode. */
+export interface TooltipSeriesValue {
+    readonly id: string;
+    readonly label: string;
+    readonly color: string;
+    readonly value: number;
+}
+/** Props passed to a custom LineChart tooltip render function (and to the
+ *  built-in `DefaultTooltip` in both React and Solid). Framework-agnostic
+ *  data shape. */
+export interface LineChartTooltipProps {
+    /** Time at the active hover position (unix-ms). */
+    t: number;
+    /** Value at the active hover position (primary series only). */
+    value: number;
+    /** Bar index in the source series; -1 when free-snap. */
+    idx: number;
+    /** Per-series values at hover.t - primary first, then secondaries. */
+    seriesValues: readonly TooltipSeriesValue[];
+    /** Pointer position in CSS pixels relative to the chart container. */
+    pointerX: number;
+    pointerY: number;
+    /** Container dimensions for placement decisions. */
+    containerWidth: number;
+    containerHeight: number;
+    /** Resolved theme + palette for color matching. */
+    theme: Theme;
+    palette: Palette;
+    /** Resolved platform locale (e.g. "en-US"). */
+    locale: string;
+    timeZone: string | undefined;
+    /** Per-chart formatter - preferred over `locale` for new tooltip code. */
+    formatter: ChartFormatter;
+}
+/** Marker mode for the visible-window high / low. */
+export type HighLowMarkers = "off" | "lines+labels" | "labels-only";
+/** Props passed to a custom extreme-tooltip render function (H/L pill hover).
+ *  Framework-agnostic data shape - same in both React and Solid. */
+export interface ExtremeTooltipProps {
+    kind: "high" | "low";
+    /** Bar index in the source series. */
+    barIdx: number;
+    price: number;
+    /** Time at the extreme bar (unix-ms). */
+    t: number;
+    /** Pointer position in CSS pixels relative to the chart container. */
+    pointerX: number;
+    pointerY: number;
+    containerWidth: number;
+    containerHeight: number;
+    theme: Theme;
+    palette: Palette;
+    /** Resolved platform locale (e.g. "en-US"). */
+    locale: string;
+    timeZone: string | undefined;
+    formatter: ChartFormatter;
+}
+export interface AreaFillThreshold {
+    /** Domain-space y to split at. `undefined` → use the resolved baseline. */
+    readonly value: number | undefined;
+    /** Pre-resolved CSS rgba string for above-threshold runs. */
+    readonly aboveColor: string;
+    /** Pre-resolved CSS rgba string for below-threshold runs. */
+    readonly belowColor: string;
+}
+/** Area-fill configuration. AreaChart sets this; LineChart renders it as a
+ * polygon between the line and a horizontal `baseline` y-value. Internal -
+ * LineChart's public surface intentionally has no area fill (that's
+ * <AreaChart>'s defining feature). Reused via `<AreaChart>` which forwards this transparently. */
+export interface AreaFillConfig {
+    baseline: AreaBaseline;
+    fillType: "flat" | "gradient";
+    fillOpacity: number;
+    /** Optional threshold split. When set, the area fill renders as two
+     *  polygons (above + below threshold) and the line stroke is split too.
+     *  Mutually exclusive with `stacked`; when
+     *  both are set, `stacked` wins (threshold becomes a no-op). */
+    threshold?: AreaFillThreshold;
+    /** Multi-series stacking mode. Resolved form (AreaChart maps user-facing
+     *  `false | true | 'normalized'` to `false | 'additive' | 'normalized'`).
+     *  - `false` (default): non-stacked. With 2+ series, each band fills
+     *    independently from the resolved baseline (overlapping fills).
+     *  - `'additive'`: bands stack, total = sum at each x.
+     *  - `'normalized'`: bands stack, total = 1 (100%) at each x. */
+    stacked?: false | "additive" | "normalized";
+}
+/** Multi-series config - one entry per line on the chart.
+ *  Each entry can override the chart-level
+ *  curveType / lineWidth / lineDash / lineDashSpacing / pointMarkers for
+ *  this one series. Without a per-series `color`, lib auto-cycles
+ *  `palette.categorical[i]`. */
+export interface SeriesConfig {
+    readonly id: string;
+    readonly data: LineSeriesInput;
+    readonly label?: string;
+    readonly color?: string;
+    readonly curveType?: CurveType;
+    readonly stepEdgeRadius?: number;
+    readonly lineWidth?: number;
+    readonly lineDash?: LineDash;
+    readonly lineDashSpacing?: number;
+    readonly pointMarkers?: PointMarkers;
+}
+/** Indicator overlays that LineChart can render on the price pane. VWAP
+ * needs OHLC + volume + session_starts and is only available on
+ * CandleChart. */
+export type LineChartIndicatorSpec = {
+    type: "sma";
+    period: number;
+    color?: string;
+} | {
+    type: "ema";
+    period: number;
+    color?: string;
+} | {
+    type: "wma";
+    period: number;
+    color?: string;
+} | {
+    type: "bollinger";
+    period: number;
+    multiplier: number;
+    color?: string;
+};
+/** Props passed to a custom connection-indicator render-prop. Framework-
+ *  agnostic data shape - the React adapter renders this via a function
+ *  returning `React.ReactNode`; the Solid adapter via `JSX.Element`; the
+ *  controller widens to `unknown`. */
+export interface ConnectionIndicatorRenderProps {
+    state: LiveState;
+    liveSince: number | undefined;
+    position: LegendPosition;
+    theme: Theme;
+    palette: Palette;
+}
+/** Props passed to a custom stale-banner render-prop. Framework-agnostic
+ *  data shape - same widening pattern as `ConnectionIndicatorRenderProps`. */
+export interface StaleBannerRenderProps {
+    state: LiveState;
+    liveSince: number | undefined;
+    theme: Theme;
+    palette: Palette;
+}
+/** Framework-agnostic LineChart prop shape. Excludes the four render-prop
+ *  fields (`tooltip`, `extremeTooltip`, `connectionIndicator`, `staleBanner`)
+ *  that each framework adapter retypes against its native JSX element type
+ *  (`React.ReactNode` for React, `JSX.Element` for Solid). The controller's
+ *  `LineChartControllerProps` extends this with `unknown`-returning render
+ *  props so both adapters' shapes are structurally assignable via covariance. */
+export interface LineChartBaseProps {
+    /** Primary series data - either structured (`{ points: Array<{t, value}> }`)
+     *  or binary (`{ times: Float64Array; values: Float64Array }`). The
+     *  binary path is zero-copy. Mutually exclusive with `series` for
+     *  multi-series charts. */
+    data?: LineSeriesInput;
+    /** Older data prepended to `data` for indicator warm-up. Lets indicators
+     *  (SMA/EMA/etc.) have priors so the visible window starts post-warmup
+     *  with non-NaN values. Same shape as `data`. */
+    historyData?: LineSeriesInput;
+    /** Multi-series mode - overrides `data`. Each entry has its own id,
+     *  label, color, and `LineSeriesInput`. The first entry is the primary
+     *  series; subsequent entries draw as secondary lines. */
+    series?: readonly SeriesConfig[];
+    /** Chart width in CSS pixels. Default 800. */
+    width?: number;
+    /** Chart height in CSS pixels. Default 300. */
+    height?: number;
+    /** Color theme - `"light"`, `"dark"`, or `"inherit"` (follows
+     *  parent provider). Default: inherits from `<ChartsProvider>`. */
+    theme?: ThemeInput;
+    /** Palette name registered in the provider (e.g. `"Monochrome"`,
+     *  `"Classic"`, `"Accessible"`). Default: inherits from provider. */
+    palette?: string;
+    /** `"Fill"` (default) = solid up/down body fills. `"Outline"` =
+     *  colored border + translucent body fill. */
+    visualStyle?: "Fill" | "Outline";
+    /** In Outline mode, the fill color inside the outlined body.
+     *  `"auto"` (default) uses chart background. */
+    outlineFillColor?: "auto" | string;
+    /** In Outline mode, alpha of the outline body fill (0–100). Default 15. */
+    outlineFillOpacity?: number;
+    /** Cap the DPR used for canvas backing-store sizing (1–2 typical).
+     *  Reduces memory on hi-DPR screens with marginal sharpness loss.
+     *  Default 2. */
+    pixelDensityCap?: number;
+    /** Skip cosmetic features (glow, animations, full DPR) for low-end
+     *  devices. Adaptive complexity auto-engages this when fps drops. */
+    fastMode?: boolean;
+    /** Force sparkline mode - minimal axis-less render. Auto-engaged
+     *  when `width < 150`. */
+    sparkline?: boolean;
+    /** Override the auto-generated `aria-label` attached to the chart
+     *  container. Default summarizes data length + type. */
+    ariaLabel?: string;
+    /** 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;
+    /** Time-axis mode per the engine boundary.
+     *  - `"wall-clock"` (default) - engine's `TimeAxis.wallClock`. Bars
+     *     are positioned at their actual unix-ms; off-hours / weekends
+     *     leave horizontal gaps.
+     *  - `"session-ordinal"` - engine's `TimeAxis.sessionOrdinal` for the
+     *     supplied market. Off-session time is collapsed; bars sit
+     *     continuously without overnight / weekend gaps. Required for
+     *     equity charts (regular session 9:30-16:00, weekdays only). */
+    timeAxisMode?: "wall-clock" | "session-ordinal";
+    /** Market spec for session-ordinal mode. Ignored when `timeAxisMode`
+     *  is `"wall-clock"` (the default). */
+    market?: "equity" | "dst-equity" | "crypto-24-7";
+    /** Toggle axis tick labels + spine. Default `true`. */
+    axisVisible?: boolean;
+    /** `"left"` (default) or `"right"`. */
+    yAxisPosition?: YAxisPosition;
+    /** `"bottom"` (default) or `"top"`. */
+    xAxisPosition?: XAxisPosition;
+    /** Fractional padding above/below the y-data range so marks don't
+     *  touch the axis edges. Default 0.05 (5%). */
+    yAxisPadding?: number;
+    /** Toggle gridlines. Default `true`. */
+    gridVisible?: boolean;
+    /** Gridline style: `"solid"` / `"dashed"` / `"dotted"`. Default `"solid"`. */
+    gridStyle?: GridStyle;
+    /** Number of gridline ticks - `"sparse"` (~3) / `"normal"` (~5) /
+     *  `"dense"` (~8). Default `"normal"`. */
+    gridDensity?: "sparse" | "normal" | "dense";
+    /** Use the palette's `accentTint` for axis + grid colors instead of
+     *  `neutral`. Default `false`. */
+    accents?: boolean;
+    /** Locale code for number/date formatting (e.g. `"USA"`, `"en-US"`).
+     *  Default: inherits from provider. */
+    locale?: string;
+    /** IANA time zone for date formatting (e.g. `"America/New_York"`).
+     *  Default: inherits from provider. */
+    timeZone?: string;
+    /** Toggle the crosshair overlay on hover. Default `true`. */
+    crosshairVisible?: boolean;
+    /** How the crosshair snaps to data: `"data"` snaps to nearest data
+     *  point, `"free"` follows pointer exactly. Default `"data"`. */
+    crosshairSnap?: CrosshairSnap;
+    /** Crosshair line span: `"horizontal"`, `"vertical"`, or `"both"`. */
+    crosshairMode?: CrosshairMode;
+    /** Crosshair line style: `"solid"` / `"dashed"` / `"dotted"`. */
+    crosshairLineStyle?: GridStyle;
+    /** Snap-marker shape at the data intersection: `"circle"` / `"square"`
+     *  / `"none"`. */
+    crosshairMarker?: CrosshairMarker;
+    indicators?: readonly LineChartIndicatorSpec[];
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    /** Decimal-place rule for price labels. Default 2. */
+    decimalPlaces?: DecimalPlaces;
+    /** ISO currency code (e.g. `"USD"`, `"EUR"`) for currency-formatted
+     *  labels. Default: inherit from provider locale. */
+    currency?: string;
+    /** `"symbol"` (default), `"code"`, or `"narrowSymbol"`. */
+    currencyDisplay?: CurrencyDisplay;
+    /** Precision for percentage-style labels. */
+    percentPrecision?: PercentPrecision;
+    /** Date format rule for time-axis labels (`"short"`, `"medium"`,
+     *  `"long"`). */
+    dateFormat?: DateFormat;
+    /** Time format rule for intraday tick labels. */
+    timeFormat?: TimeFormat;
+    /** Style of the last-price horizontal reference line: `"solid"` /
+     *  `"dashed"` / `"dotted"` / `false` to hide. Default `"solid"`. */
+    lastPriceLine?: LastPriceLineStyle;
+    /** Show the last price as a pill on the y-axis. Default `true`. */
+    lastPriceLabel?: boolean;
+    /** Override the chart background color (CSS). Default: theme-derived. */
+    chartBgColor?: string;
+    /** Show high + low markers on the visible data range:
+     *  `"lines+labels"` (default), `"labels"`, `"off"`. */
+    highLowMarkers?: HighLowMarkers;
+    /** Live-bar animation: `"glow"` / `"dot"` / `"pulse-bar"` / `"none"`. */
+    liveBarIndicator?: LiveBarIndicator;
+    /** Anchor for the connection-indicator badge + legend overlay:
+     *  `"top-left"` (default), `"top-right"`, `"bottom-left"`,
+     *  `"bottom-right"`. */
+    legendPosition?: LegendPosition;
+    /** Legend visibility: `"on"` (default), `"off"`, `"on-hover"`. */
+    legend?: LegendVisibility;
+    /** Visual treatment for stale connection state: `"banner"`,
+     *  `"desaturate-pulse"`, `"desaturate-pulse + banner"`, `"off"`. */
+    staleVisualization?: StaleVisualization;
+    /** Unix-ms timestamp of the latest accepted tick. Used to drive
+     *  the live/stale state machine + auto-stale timeout. */
+    liveSince?: number;
+    /** Host-asserted connection state - overrides `liveSince`-derived
+     *  state when present. `"live"` / `"stale"` / `"disconnected"`. */
+    connectionState?: LiveState;
+    /** Milliseconds after the last `liveSince` tick before the chart
+     *  auto-transitions to `"stale"`. Default 5000. */
+    staleThreshold?: number;
+    /** Host-forced reduced-motion override. When unset the chart reads
+     *  the user's `prefers-reduced-motion` media query. */
+    reducedMotion?: boolean;
+    /** Curve interpolation between points: `"linear"`, `"monotone"`,
+     *  `"step"`, `"step-before"`, `"step-after"`, `"basis"`, `"natural"`,
+     *  `"bump"`, or a parameterized form. Default `"linear"`. */
+    curveType?: CurveType;
+    /** When `curveType` is a `"step-*"` variant, radius (CSS px) for
+     *  rounded step corners. `0` (default) = square. */
+    stepEdgeRadius?: number;
+    /** Series stroke width in CSS px. Default 2. */
+    lineWidth?: number;
+    /** Dash pattern: `"solid"`, `"dashed"`, `"dotted"`. */
+    lineDash?: LineDash;
+    /** Multiplier for the dash gap when `lineDash !== "solid"`. */
+    lineDashSpacing?: number;
+    /** Per-point markers along the line: `"circle"`, `"diamond"`,
+     *  `"square"`, `"off"`. */
+    pointMarkers?: PointMarkers;
+    /** Area-fill config - when set, renders a filled polygon between the
+     *  line and a horizontal baseline. Switches the chart to AreaChart
+     *  visuals. See `AreaFillConfig` for full options. */
+    areaFill?: AreaFillConfig;
+    /** Direction-colored aura behind marks. */
+    glow?: import('../personalization/axes/glow').GlowInput;
+    /** `'auto'` = direction-colored from palette;
+     *  literal color = uniform glow regardless of direction. */
+    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 STALE_KEYFRAMES_ID = "tickyr-stale-keyframes";
+export declare function ensureStaleKeyframes(): void;
+export declare const SPARKLINE_THRESHOLD_PX = 150;
+export declare const DEFAULT_FONT = "system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif";
+export declare const DEFAULT_AXIS_FONT_SIZE = 11;
+export declare const Y_AXIS_RESERVE_PX = 80;
+export declare const X_AXIS_RESERVE_PX = 26;
+export declare const TICK_LENGTH_PX = 4;
+export declare const LABEL_GAP_PX = 4;
+export declare const DEFAULT_SERIES_STROKE = 2;
+export declare const GRID_TARGET: Record<"sparse" | "normal" | "dense", number>;
+export declare function liveBarMaxRadius(mode: LiveBarIndicator): number;
+export interface ChartLayout {
+    viewport: Viewport;
+    innerLeft: number;
+    innerRight: number;
+    innerTop: number;
+    innerBottom: number;
+    yScale: LinearScale;
+    yTicks: NiceTick[];
+    xTicks: XAxisTick[];
+    startMs: number;
+    endMs: number;
+}
+export interface ChartHandle {
+    staticCtx: CanvasRenderingContext2D;
+    dynamicCtx: CanvasRenderingContext2D | null;
+    layout: ChartLayout;
+    personalization: Personalization;
+    timeAxis: TimeAxisHandle;
+    crosshairLineColor: string;
+    crosshairMarkerFill: string;
+    crosshairMarkerStroke: string;
+    /** When `areaFill.threshold` is on, the crosshair marker re-colors to
+     *  match whichever side of the threshold the hover.value lands on
+     *  (above/below). Null when no threshold split is active - the static
+     *  `crosshairMarkerStroke` wins. */
+    thresholdMarker: {
+        y: number;
+        aboveStroke: string;
+        belowStroke: string;
+    } | null;
+    extremes: ExtremeMarkerState | null;
+    lastX: number;
+    lastY: number;
+    directionColor: string;
+    /** Multi-series - secondary series' last (x, y) + resolved color, so
+     *  the live-bar marker can render at each line's tip. */
+    secondaryLastPositions: ReadonlyArray<{
+        x: number;
+        y: number;
+        color: string;
+    }>;
+    /** Per-secondary lookup data so the crosshair can drop a snap marker on
+     *  each series at the cursor x. */
+    secondaryLookups: ReadonlyArray<{
+        times: Float64Array;
+        values: Float64Array;
+        color: string;
+    }>;
+    accentColor: string;
+    bgColor: string;
+    liveBarFontSize: number;
+    liveStateColor: string;
+    staleStateColor: string;
+    disconnectedStateColor: string;
+    textColor: string;
+}
+export interface LiveStateInputs {
+    liveSince: number | undefined;
+    connectionState: LiveState | undefined;
+    staleThreshold: number;
+}
+export interface DynamicCfg {
+    crosshairVisible: boolean;
+    crosshairLineStyle: GridStyle;
+    crosshairMarker: CrosshairMarker;
+}
+export declare const DEFAULT_DYNAMIC_CFG: DynamicCfg;
+export interface ExtremeMarkerState {
+    high: {
+        idx: number;
+        t: number;
+        price: number;
+        pillBox: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        } | null;
+    };
+    low: {
+        idx: number;
+        t: number;
+        price: number;
+        pillBox: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        } | null;
+    };
+}
+export interface HoverState {
+    pointerX: number;
+    pointerY: number;
+    snapX: number;
+    snapY: number;
+    idx: number;
+    t: number;
+    value: number;
+}
+export interface ExtremeHoverState {
+    kind: "high" | "low";
+    pointerX: number;
+    pointerY: number;
+    idx: number;
+    t: number;
+    price: number;
+}
+export type ResolvedIndicator = {
+    spec: Extract<LineChartIndicatorSpec, {
+        type: "sma" | "ema" | "wma";
+    }>;
+    kind: "single";
+    values: Float64Array;
+    color: string;
+} | {
+    spec: Extract<LineChartIndicatorSpec, {
+        type: "bollinger";
+    }>;
+    kind: "bollinger";
+    upper: Float64Array;
+    middle: Float64Array;
+    lower: Float64Array;
+    color: string;
+    /** Translucent fill color for the area between upper and lower -
+     *  alpha varies with `visualStyle` (Fill = 0.14, Outline = 0.05). */
+    bandFill: string;
+};
+export declare function findExtremeIndices(series: LineSeries): {
+    highIdx: number;
+    lowIdx: number;
+};
+export declare function defaultAriaLabel(series: LineSeries): string;
+export declare function computeYDomain(series: LineSeries, padding: number, indicators: readonly ResolvedIndicator[], areaBaselineY: number | undefined, secondarySeries?: readonly {
+    ingested: LineSeries;
+}[], stackedTop?: Float64Array | undefined): {
+    min: number;
+    max: number;
+};
+export declare function xToPxLinear(t: number, layout: ChartLayout): number;
+export declare function pxToTime(px: number, layout: ChartLayout): number;
+export declare function indicatorPaletteColor(spec: LineChartIndicatorSpec, personalization: Personalization): string;
+export declare function computeIndicator(spec: LineChartIndicatorSpec, series: LineSeries, personalization: Personalization, 
+/** Number of leading bars in `series` that are warmup-only (from
+ *  `historyData`). Indicator outputs are sliced to drop these so
+ *  the result aligns with the visible-only series. */
+historyLen: number): Promise<ResolvedIndicator>;
+export declare function computeLayout(opts: {
+    series: LineSeries;
+    viewport: Viewport;
+    yAxisPosition: YAxisPosition;
+    xAxisPosition: XAxisPosition;
+    yAxisPadding: number;
+    gridDensity: "sparse" | "normal" | "dense";
+    axisVisible: boolean;
+    timeAxis: TimeAxisHandle;
+    indicators: readonly ResolvedIndicator[];
+    liveBarIndicator: LiveBarIndicator;
+    formatter: ChartFormatter;
+    /** AreaChart's resolved baseline (domain-space y); extends y-domain. */
+    areaBaselineY: number | undefined;
+    /** Multi-series secondary entries; their value extents extend y-domain. */
+    secondarySeries: readonly SecondarySeriesDraw[];
+    /** When stacked-area is on, the cumulative-top across all bands per x.
+     *  Forces the y-domain to [0, max(stackTop)] regardless of raw values. */
+    stackedTop: Float64Array | undefined;
+    /** Vertical space (CSS px) reserved at the top of the canvas for the
+     *  legend overlay, when the legend is on-screen and anchored to a top
+     *  corner. Pushes innerTop down so the legend never overlaps data. */
+    legendReserveTop: number;
+    /** Vertical space reserved at the bottom for a bottom-anchored legend. */
+    legendReserveBottom: number;
+}): ChartLayout;
+export declare function drawSparkline(ctx: CanvasRenderingContext2D, series: LineSeries, viewport: Viewport, personalization: Personalization, path: Path2D, areaFill: AreaFillConfig | undefined, curveFactory: CurveFactory, lineWidth: number, lineDashPattern: number[]): void;
+export interface DrawFullArgs {
+    ctx: CanvasRenderingContext2D;
+    series: LineSeries;
+    layout: ChartLayout;
+    personalization: Personalization;
+    path: Path2D;
+    yAxisPosition: YAxisPosition;
+    xAxisPosition: XAxisPosition;
+    gridVisible: boolean;
+    gridStyle: GridStyle;
+    axisVisible: boolean;
+    accents: boolean;
+    indicators: readonly ResolvedIndicator[];
+    lastPriceLine: LastPriceLineStyle;
+    lastPriceLabel: boolean;
+    lastPriceText: string;
+    chartBgColor: string;
+    highLowMarkers: HighLowMarkers;
+    highIdx: number;
+    lowIdx: number;
+    formatter: ChartFormatter;
+    /** AreaChart fill polygon. Resolved baseline + opacity; color is auto-
+     * derived from the line direction (up/down). Undefined = LineChart mode. */
+    areaFill: AreaFillConfig | undefined;
+    areaBaselineY: number | undefined;
+    /** Resolved d3-shape curve factory for the line + area top-edge. */
+    curveFactory: CurveFactory;
+    /** Stroke width for the main series line. */
+    lineWidth: number;
+    /** Pre-resolved dash pattern for the main series line. Empty = solid. */
+    lineDashPattern: number[];
+    /** Resolved marker config, or null when `pointMarkers` is false / undefined. */
+    markers: ResolvedMarkerConfig | null;
+    /** Pre-resolved color for the primary series. `undefined` = use the
+     *  direction-aware palette.up/down. Passed by AreaChart / multi-series
+     *  mode to override direction logic. */
+    primaryColorOverride: string | undefined;
+    /** Additional series to render on top of the primary. Each one carries
+     *  its own resolved style + color. Empty array = single-series mode. */
+    secondarySeries: readonly SecondarySeriesDraw[];
+    /** Pre-built stacked-area layout. When non-null:
+     *   - Area fills draw as N vertically-stacked bands (`drawStackedAreaFill`).
+     *   - Each line stroke (primary + each secondary) follows that band's
+     *     cumulative top instead of the raw series values.
+     *   - Y-domain extends from 0 to max(stackTop). For 'normalized', that's
+     *     [0, 1].
+     *   - `areaFill.threshold`, last-price line, last-price label, H/L
+     *     markers, and indicator overlays are all suppressed (their
+     *     single-series semantics don't compose with stacked bands).
+     *  Null = non-stacked path (overlapping fills for multi-series, single
+     *  fill for single-series - both go through the original code path). */
+    stackedLayout: StackingLayout | null;
+}
+/** A non-primary series rendered alongside the main series. Carries the
+ *  ingested data + a fully-resolved per-series style so the draw loop is
+ *  configuration-free. */
+export interface SecondarySeriesDraw {
+    readonly ingested: LineSeries;
+    readonly color: string;
+    readonly curveFactory: CurveFactory;
+    readonly lineWidth: number;
+    readonly lineDashPattern: number[];
+    readonly markers: ResolvedMarkerConfig | null;
+}
+export interface DrawFullResult {
+    extremes: ExtremeMarkerState | null;
+}
+export declare function drawFullLineChart(args: DrawFullArgs): DrawFullResult;
+/** Single owner of the dynamic-layer draw - clears, paints the live-bar
+ *  + connection indicator (per personalization), and draws the crosshair
+ *  on top when hovered. Both pointer events and the rAF loop call this. */
+export declare function drawDynamicLayer(h: ChartHandle, hover: HoverState | null, now: number, reducedMotion: boolean, cfg: DynamicCfg, liveStateInputs: LiveStateInputs, dirtyRects?: readonly Rect[] | null, dirtyCount?: number): void;