@abdullahjaswal/tickyr-charts-solid 0.1.0

package/LICENSE

@@ -0,0 +1,14 @@
+Copyright (c) 2026 Abdullah Jaswal. All rights reserved.
+
+This source code is made publicly available for reference and evaluation
+only. No license or permission is granted to use, copy, modify, merge,
+publish, distribute, sublicense, or sell copies of the software, or to create
+derivative works from it, in whole or in part, without the prior written
+consent of the copyright holder.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/AbdullahJaswal/tickyr-charts/main/assets/brand/logo-light.png" alt="Tickyr Charts" width="84" height="84">
+</p>
+
+<h1 align="center">Tickyr Charts for SolidJS</h1>
+
+<p align="center">
+  Opinionated, canvas-rendered charts for trading and financial-data visualization.<br />
+  Powered by a Rust engine compiled to WASM. Self-contained - no other Tickyr package required.
+</p>
+
+## Install
+
+```sh
+bun add @abdullahjaswal/tickyr-charts-solid solid-js
+# or: npm install @abdullahjaswal/tickyr-charts-solid solid-js
+```
+
+`solid-js` is a peer dependency.
+
+## Quick start
+
+```tsx
+import { ChartsProvider, CandleChart } from "@abdullahjaswal/tickyr-charts-solid"
+
+function App() {
+  return (
+    <ChartsProvider theme="dark" palette="Monochrome">
+      <CandleChart
+        data={{ candles: ohlcBars }}
+        width={900}
+        height={400}
+        indicators={[{ type: "rsi", period: 14 }]}
+        vwap={{ visible: true }}
+      />
+    </ChartsProvider>
+  )
+}
+```
+
+Full prop tables, the chart gallery, and the React build (`@abdullahjaswal/tickyr-charts-react`) live in the main repo:
+
+**https://github.com/AbdullahJaswal/tickyr-charts**

package/dist/animation/animator.d.ts

@@ -0,0 +1,52 @@
+export interface AnimationField {
+    /** Pool slot index. -1 means "released". */
+    readonly slot: number;
+}
+export interface AnimationProgress {
+    /** Eased progress in [0, 1]. */
+    readonly progress: number;
+    /** Linear progress in [0, 1]. */
+    readonly linear: number;
+    /** True once `linear === 1` (animation complete). */
+    readonly done: boolean;
+}
+export type EaseId = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export declare const Ease: {
+    readonly Linear: EaseId;
+    readonly OutCubic: EaseId;
+    readonly InCubic: EaseId;
+    readonly InOutCubic: EaseId;
+    readonly OutQuad: EaseId;
+    readonly OutBack: EaseId;
+    readonly OutElastic: EaseId;
+};
+export declare class AnimationPool {
+    private readonly startAt;
+    private readonly endsAt;
+    private readonly easeIds;
+    private readonly free;
+    private freeTop;
+    /** Logical length - high-water mark of slot indices ever used. */
+    private highWater;
+    readonly capacity: number;
+    constructor(capacity: number);
+    /** Reserve a slot. Returns the index. Caller-owned until `release()`.
+     *  Throws if the pool is full (capacity exceeded). */
+    acquire(now: number, durationMs: number, ease?: EaseId): number;
+    release(i: number): void;
+    /** Read the eased + linear progress of slot `i` at `now`. Pure
+     *  function of pool state. Does not allocate. */
+    read(i: number, now: number, out: ProgressView): void;
+    /** Whether slot `i` has finished (linear progress >= 1). Cheap O(1)
+     *  read for the rAF loop's "should I keep going" check. */
+    isDone(i: number, now: number): boolean;
+}
+/** Mutable view returned by `pool.read(slot, now, view)`. The render
+ *  path keeps one of these on the stack and re-uses it across all
+ *  active animations to avoid per-frame allocations. */
+export interface ProgressView {
+    linear: number;
+    progress: number;
+    done: boolean;
+}
+export declare function createProgressView(): ProgressView;

package/dist/animation/bar-entry.d.ts

@@ -0,0 +1,44 @@
+import { BarEntryAnimation } from '../personalization/axes/animation';
+export interface EntryEffect {
+    /** Multiplier for the bar's vertical extent. 1 = fully grown.
+     *  `'grow-from-baseline'` and `'rise-from-low'` use this to shrink
+     *  the body-and-wick towards a fixed pivot. */
+    scaleY: number;
+    /** Pivot for `scaleY` in CSS px (within the bar's local frame).
+     *  `'grow-from-baseline'` → innerBottom; `'rise-from-low'` → bar.l;
+     *  `'scale'` → bar center. */
+    pivotY: number;
+    /** X offset in CSS px applied additively to the bar's center x. */
+    offsetX: number;
+    /** Y offset in CSS px applied additively (positive = down). */
+    offsetY: number;
+    /** Multiplier for body-width. `'expand-x'` ramps this 0→1. */
+    widthScale: number;
+    /** Alpha 0–1 applied to the entire bar's draw. */
+    alpha: number;
+    /** When true, the bar is fully clipped out (used by `'wipe'`). */
+    clipped: boolean;
+}
+declare const _scratch: EntryEffect;
+/** Reset the effect view to identity. The render path always calls
+ *  this before dispatching so partially-mutated state never leaks. */
+export declare function resetEntryEffect(out: EntryEffect): void;
+export interface EntryGeom {
+    innerLeft: number;
+    innerRight: number;
+    innerTop: number;
+    innerBottom: number;
+    /** Linear progress in [0, 1] for the chart-wide entry animation. */
+    globalProgress: number;
+    /** Bar's own y for "rise-from-low". */
+    barLowY: number;
+    /** Bar's center x. */
+    barCenterX: number;
+    /** Bar index + total bar count for staggered presets. */
+    barIndex: number;
+    barCount: number;
+}
+/** Compute per-bar effect for `preset` at the given progress. Mutates
+ *  `out` in place and returns it. `'none'` is the identity case. */
+export declare function applyBarEntryEffect(preset: BarEntryAnimation, geom: EntryGeom, out: EntryEffect): EntryEffect;
+export { _scratch as ENTRY_EFFECT_SCRATCH };

package/dist/animation/bar-update.d.ts

@@ -0,0 +1,38 @@
+import { BarUpdateAnimation } from '../personalization/axes/animation';
+export interface UpdateEffect {
+    /** Multiplier on the bar's vertical extent - `'pulse'` ramps 1→1.08→1.
+     *  `'rise'` is encoded via `offsetY` instead. */
+    scaleY: number;
+    /** Vertical offset in CSS px - `'rise'` lifts up to 6px and settles. */
+    offsetY: number;
+    /** Tint blend (0–1) applied to the bar fill towards `tintColor`. */
+    tintBlend: number;
+    /** Tint color in CSS rgba string (resolved by the chart). */
+    tintColor: string;
+    /** Halo radius in CSS px for `'glow'` (0 = no halo). */
+    glowRadius: number;
+    /** When > 0, draws a horizontal line at `tickLineY` with this alpha. */
+    tickLineAlpha: number;
+    /** y-coordinate of the tick line in CSS px. */
+    tickLineY: number;
+    /** Alpha multiplier for the bar (used by `'flicker'`). */
+    alpha: number;
+    /** Should the OHLC values be lerped from the previous frame's values? */
+    morph: boolean;
+}
+declare const _scratch: UpdateEffect;
+export declare function resetUpdateEffect(out: UpdateEffect): void;
+export interface UpdateInputs {
+    /** Linear progress in [0, 1]. */
+    progress: number;
+    /** New close - prev close. Sign drives `'flash-direction'` color. */
+    directionSign: 1 | -1 | 0;
+    /** Pre-resolved colors for direction / neutral flash. */
+    upColor: string;
+    downColor: string;
+    neutralColor: string;
+    /** Last bar's close in CSS px (for tick-line). */
+    lastCloseY: number;
+}
+export declare function applyBarUpdateEffect(preset: BarUpdateAnimation, inp: UpdateInputs, out: UpdateEffect): UpdateEffect;
+export { _scratch as UPDATE_EFFECT_SCRATCH };

package/dist/animation/easings.d.ts

@@ -0,0 +1,22 @@
+export type EaseFn = (t: number) => number;
+/** Classic CSS ease shapes - `t` clamped to [0, 1]. */
+export declare const easeLinear: EaseFn;
+export declare const easeOutCubic: EaseFn;
+export declare const easeInCubic: EaseFn;
+export declare const easeInOutCubic: EaseFn;
+export declare const easeOutQuad: EaseFn;
+/** Standard CSS easeOutBack - overshoots ~10% mid-curve. Used by the
+ *  `'wave'` entry preset where pronounced overshoot is intentional.
+ *  Pure function, no allocations. */
+export declare const easeOutBack: EaseFn;
+/** Subtle spring used by the `'spring'` entry preset on candle bodies.
+ *  Same closed-form shape as easeOutBack but with a much smaller
+ *  overshoot coefficient - peaks at ~1.025 instead of ~1.10. This
+ *  delivers the spec's "bounce into place" feel without making bars
+ *  visibly larger than their final size on a financial chart (where
+ *  even a few-percent flash reads as a sizing stutter). */
+export declare const easeOutSpringSubtle: EaseFn;
+/** Damped sine - used by `glow` / `flicker` update presets. */
+export declare const easeOutElastic: EaseFn;
+/** Triangle wave - used for `pulse` (peak at 0.5, returns to 0). */
+export declare const easeTriangle: EaseFn;

package/dist/animation/index.d.ts

@@ -0,0 +1,4 @@
+export { AnimationPool, Ease, type EaseId, type ProgressView, createProgressView, type AnimationProgress, } from './animator';
+export { easeLinear, easeOutCubic, easeInCubic, easeInOutCubic, easeOutQuad, easeOutBack, easeOutSpringSubtle, easeOutElastic, easeTriangle, type EaseFn, } from './easings';
+export { applyBarEntryEffect, resetEntryEffect, ENTRY_EFFECT_SCRATCH, type EntryEffect, type EntryGeom, } from './bar-entry';
+export { applyBarUpdateEffect, resetUpdateEffect, UPDATE_EFFECT_SCRATCH, type UpdateEffect, type UpdateInputs, } from './bar-update';

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

@@ -0,0 +1,98 @@
+import { LineSeries } from '../domain';
+import { Personalization, ChartFormatter } from '../personalization';
+import { Orientation } from '../viewport/orientation';
+import { StackingLayout } from '../rendering/stacked-layout';
+import { ResolvedLabelConfig } from '../personalization/axes/value-labels';
+import { HoverState, SecondaryBarSeriesDraw, BarChartBaseProps, BarChartTooltipProps } from './bar-chart-helpers';
+/** Provider snapshot - same shape as LineChart's. Kept structural so
+ *  this file stays framework-agnostic. */
+export interface BarChartProviderSnapshot {
+    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 renders into JSX. */
+export interface BarChartRenderContext {
+    personalization: Personalization;
+    formatter: ChartFormatter;
+    resolvedLocaleBase: string;
+    resolvedTimeZone: string | undefined;
+    series: LineSeries;
+    secondarySeriesList: readonly SecondaryBarSeriesDraw[];
+    stackedLayout: StackingLayout | null;
+    primaryColor: string | undefined;
+    resolvedValueLabels: ResolvedLabelConfig | null;
+    ariaLabel: string;
+    isSparkline: boolean;
+    cssWidth: number;
+    cssHeight: number;
+    orientation: Orientation;
+}
+export interface BarChartControllerCallbacks {
+    onContextChange(ctx: BarChartRenderContext): void;
+    onHoverChange(hover: HoverState | null): void;
+}
+/** Controller-specific prop type. Extends the framework-agnostic
+ *  `BarChartBaseProps` (in `bar-chart-helpers.ts`) with the `tooltip`
+ *  field 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 BarChartControllerProps extends BarChartBaseProps {
+    tooltip?: undefined | false | ((p: BarChartTooltipProps) => unknown);
+}
+export interface BarChartControllerMountOptions extends BarChartControllerCallbacks {
+    /** Outer container - used by the visibility source to pause draws
+     *  when the chart is off-screen. */
+    container?: HTMLElement | null;
+    staticCanvas: HTMLCanvasElement;
+    dynamicCanvas: HTMLCanvasElement | null;
+    initialProps: BarChartControllerProps;
+    initialProvider: BarChartProviderSnapshot;
+}
+export declare class BarChartController {
+    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 secondarySeriesList;
+    private stackedLayout;
+    private primaryColor;
+    private resolvedValueLabels;
+    private isSparkline;
+    private orientation;
+    private staticDrawAbort;
+    private disposed;
+    private visGate;
+    /** Stored container reference for `getBoundingClientRect()` inside
+     *  pointer handlers. We can't rely on `e.currentTarget` - happy-dom
+     *  (and some real browsers in non-React dispatch paths) clear it
+     *  after event dispatch, so reading it later returns null. */
+    private container;
+    constructor(opts: BarChartControllerMountOptions);
+    update(props: BarChartControllerProps, providerCtx: BarChartProviderSnapshot): void;
+    handlePointerMove(e: PointerEvent): void;
+    handlePointerLeave(): void;
+    dispose(): void;
+    private setHover;
+    private resolveDerived;
+    private applyDynamicCfgFromProps;
+    private runStaticDraw;
+}
+export type { HoverState, ChartHandle, DynamicCfg, SecondaryBarSeriesDraw, BarChartBaseProps, } from './bar-chart-helpers';

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

@@ -0,0 +1,334 @@
+import { LineSeries, LineSeriesInput } from '../domain';
+import { Personalization, ThemeInput, DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat, LegendPosition, LegendVisibility, 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 { CrosshairMarker } from '../rendering/draw/crosshair';
+import { Orientation } from '../viewport/orientation';
+import { StackingLayout } from '../rendering/stacked-layout';
+import { ResolvedLabelConfig } from '../personalization/axes/value-labels';
+/** Public input shape - same SoA + AoS pair as LineChart so hosts can
+ *  share data pipelines between line / area / bar without re-shaping. */
+export type BarChartSeriesInput = LineSeriesInput;
+/** Multi-series config - one entry per side-by-side bar at each x-slot.
+ *  Without per-series `color`, the lib auto-
+ *  cycles `palette.categorical[i]`. All series MUST share the same `times`
+ *  view (validated at the public API boundary). */
+export interface BarSeriesConfig {
+    readonly id: string;
+    readonly data: BarChartSeriesInput;
+    readonly label?: string;
+    readonly color?: string;
+}
+/** Multi-series rendering mode. */
+export type BarGrouping = "clustered" | "stacked" | "normalized" | "overlapping";
+/** Per-series value at the hover slot - every visible series at that x. */
+export interface BarTooltipSeriesValue {
+    readonly id: string;
+    readonly label: string;
+    readonly color: string;
+    readonly value: number;
+}
+/** Props passed to a custom tooltip render function. Mirrors
+ *  `LineChartTooltipProps` but tailored to bar geometry (no
+ *  threshold-fill semantics; bar-snap uses the slot index). */
+export interface BarChartTooltipProps {
+    /** Time at the hovered bar (unix-ms). */
+    readonly t: number;
+    /** Bar index (0-based). */
+    readonly idx: number;
+    /** Per-series values at this x. */
+    readonly seriesValues: readonly BarTooltipSeriesValue[];
+    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;
+}
+/** Framework-agnostic BarChart prop shape. Excludes the `tooltip` render-
+ *  prop field that each framework adapter retypes against its native JSX
+ *  element type. The controller's `BarChartControllerProps` extends this
+ *  with an `unknown`-returning tooltip so both adapters' shapes are
+ *  structurally assignable via covariance. */
+export interface BarChartBaseProps {
+    /** Bar data - single series (categories + values). Mutually
+     *  exclusive with `series` for multi-series. */
+    data?: BarChartSeriesInput;
+    /** Multi-series mode: multiple parallel series. Layout follows
+     *  `grouping` (grouped / stacked / normalized). */
+    series?: readonly BarSeriesConfig[];
+    /** Multi-series layout: `"grouped"` (side-by-side bars per
+     *  category), `"stacked"` (vertically stacked), `"normalized"`
+     *  (stacked to 100%). */
+    grouping?: BarGrouping;
+    /** Padding between bar groups (0–1 fraction of slot width). */
+    groupPadding?: number;
+    /** Chart orientation: `"vertical"` (default, value on y) or
+     *  `"horizontal"` (value on x). */
+    orientation?: import('../viewport/orientation').Orientation;
+    /** Render the bar value as a text label on/near the bar. */
+    valueLabels?: import('../personalization/axes/value-labels').ValueLabels;
+    /** Legend visibility. */
+    legend?: LegendVisibility;
+    /** Legend anchor corner. */
+    legendPosition?: LegendPosition;
+    /** Toggle crosshair on hover. */
+    crosshairVisible?: boolean;
+    /** Crosshair line style. */
+    crosshairLineStyle?: GridStyle;
+    /** Snap-marker shape. */
+    crosshairMarker?: CrosshairMarker;
+    /** Chart width in CSS px. Default 800. */
+    width?: number;
+    /** Chart height in CSS px. Default 300. */
+    height?: number;
+    /** Color theme. */
+    theme?: ThemeInput;
+    /** Palette name. */
+    palette?: string;
+    /** `"Fill"` (default) or `"Outline"`. */
+    visualStyle?: "Fill" | "Outline";
+    /** Outline-mode fill color. */
+    outlineFillColor?: "auto" | string;
+    /** Outline-mode fill opacity (0–100). */
+    outlineFillOpacity?: number;
+    /** Cap the DPR. */
+    pixelDensityCap?: number;
+    /** Skip cosmetic features for low-end devices. */
+    fastMode?: boolean;
+    /** Direction-colored aura behind marks. */
+    glow?: import('../personalization/axes/glow').GlowInput;
+    /** Glow color rule. `"auto"` = direction-derived. */
+    glowColor?: import('../personalization/axes/glow').GlowColorInput;
+    /** Pattern fills (hatch, dots, etc.). */
+    pattern?: import('../personalization/axes/pattern').PatternInput;
+    /** Pattern scale multiplier. */
+    patternScale?: number;
+    /** Pattern color rule. `"auto"` = derived from bar color. */
+    patternColor?: import('../personalization/axes/pattern').PatternColorInput;
+    /** Force sparkline mode. */
+    sparkline?: boolean;
+    /** Override the auto-generated `aria-label`. */
+    ariaLabel?: string;
+    /** Toggle axis labels + spine. */
+    axisVisible?: boolean;
+    /** Value-axis position (depends on `orientation`). */
+    yAxisPosition?: YAxisPosition;
+    /** Category-axis position. */
+    xAxisPosition?: XAxisPosition;
+    /** Padding above/below the value-axis data range (fraction). */
+    yAxisPadding?: number;
+    /** Toggle gridlines. */
+    gridVisible?: boolean;
+    /** Gridline style. */
+    gridStyle?: GridStyle;
+    /** Gridline density. */
+    gridDensity?: "sparse" | "normal" | "dense";
+    /** Use accent tint for axis + grid. */
+    accents?: boolean;
+    /** Locale code. */
+    locale?: string;
+    /** IANA time zone. */
+    timeZone?: string;
+    /** Fraction of slot width consumed by the bar body (0–1).
+     *  Default 0.7. */
+    barWidthRatio?: number;
+    /** Bar corner radius in CSS px. Default 3. */
+    cornerRadius?: number;
+    /** Bar border width in CSS px. */
+    borderWidth?: number;
+    /** Digit-grouping rule (`"thousands"` / `"lakh-crore"` / `"none"`). */
+    digitGrouping?: DigitGrouping;
+    /** Compact number abbreviation rule. */
+    numberAbbreviation?: NumberAbbreviation;
+    /** Decimal-place rule for value labels. */
+    decimalPlaces?: DecimalPlaces;
+    /** ISO currency code. */
+    currency?: string;
+    /** Currency display style. */
+    currencyDisplay?: CurrencyDisplay;
+    /** Percentage precision. */
+    percentPrecision?: PercentPrecision;
+    /** Date format rule for time-axis category labels. */
+    dateFormat?: DateFormat;
+    /** Time format rule. */
+    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 DEFAULT_BAR_WIDTH_RATIO = 0.7;
+export declare const DEFAULT_GROUP_PADDING = 0.2;
+/** Container width below which sparkline mode auto-engages. Matches
+ *  LineChart's `SPARKLINE_THRESHOLD_PX`. */
+export declare const SPARKLINE_THRESHOLD_PX = 150;
+/** Constant shrink-ratio per subsequent band in `grouping: 'overlapping'`.
+ *  Each band is `OVERLAP_SHRINK_RATIO` × the previous band's width, so
+ *  progressively narrower bars layer on top of the wider band 0.
+ *  Internal token (not a user axis) - calibrated for visual rhythm
+ *  matching CandleChart's `bodyWidthRatio: 0.7`. */
+export declare const OVERLAP_SHRINK_RATIO = 0.7;
+/** A non-primary series rendered alongside the primary in multi-series
+ *  mode. Carries the ingested data + the resolved per-series color so
+ *  the draw loop is configuration-free. */
+export interface SecondaryBarSeriesDraw {
+    readonly ingested: LineSeries;
+    readonly color: string;
+}
+/** Pointer-driven hover state. `idx` is the bar's index in the primary
+ *  series; `t` is its time, `value` is its value. snapX/snapY are the
+ *  bar's center pixel (where the crosshair marker pins). */
+export interface HoverState {
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly snapX: number;
+    readonly snapY: number;
+    readonly idx: number;
+    readonly t: number;
+    readonly value: number;
+}
+export interface DynamicCfg {
+    readonly crosshairVisible: boolean;
+    readonly crosshairLineStyle: GridStyle;
+    readonly crosshairMarker: CrosshairMarker;
+}
+/** Pre-resolved per-frame draw inputs for the dynamic layer (crosshair
+ *  + snap markers). Captured at static-layer-paint time so the
+ *  pointer-event handlers don't recompute personalization-derived
+ *  colors per frame. */
+export interface ChartHandle {
+    readonly dynamicCtx: CanvasRenderingContext2D | null;
+    readonly layout: ChartLayout;
+    readonly crosshairLineColor: string;
+    readonly crosshairMarkerFill: string;
+    readonly crosshairMarkerStroke: string;
+    /** Per-secondary lookup: snap marker drops a small dot at each
+     *  series' value at the cursor x. */
+    readonly secondaryLookups: ReadonlyArray<{
+        times: Float64Array;
+        values: Float64Array;
+        color: string;
+    }>;
+}
+export interface ChartLayout {
+    innerLeft: number;
+    innerRight: number;
+    innerTop: number;
+    innerBottom: number;
+    /** Vertical (default): bars rise from x-axis baseline. Horizontal:
+     *  bars extend from y-axis baseline. */
+    orientation: Orientation;
+    /** Maps a numeric VALUE (the data) to a pixel along the value axis.
+     *    - vertical: y-pixel; rangeStart=innerBottom, rangeEnd=innerTop
+     *      (inverted so larger values render higher).
+     *    - horizontal: x-pixel; rangeStart=innerLeft, rangeEnd=innerRight
+     *      (larger values render farther right). */
+    valueScale: LinearScale;
+    /** Maps a CATEGORY time (`series.times[i]`, in unix-ms) to a pixel
+     *  along the category axis.
+     *    - vertical: x-pixel; rangeStart=innerLeft+halfSlot,
+     *      rangeEnd=innerRight-halfSlot.
+     *    - horizontal: y-pixel; rangeStart=innerTop+halfSlot,
+     *      rangeEnd=innerBottom-halfSlot. */
+    categoryScale: LinearScale;
+    /** Numeric ticks for the value axis (from `niceTicks` over the data
+     *  domain). Same regardless of orientation. */
+    valueTicks: readonly NiceTick[];
+    /** Bar-position ticks for the category axis (from
+     *  `buildBarPositionTicks`). Same regardless of orientation. */
+    categoryTicks: readonly XAxisTick[];
+    startMs: number;
+    endMs: number;
+    /** Half the slot extent (in slot-axis pixels) PLUS AXIS_BAR_GAP_PX.
+     *  Used to inset bar centers from the category-axis spine so first/
+     *  last bars sit visibly inside the chart. */
+    halfSlot: number;
+    viewport: Viewport;
+}
+export declare function computeYDomain(series: LineSeries, padding: number, secondarySeries?: readonly SecondaryBarSeriesDraw[], stackedLayout?: StackingLayout | null): {
+    min: number;
+    max: number;
+};
+export declare function computeLayout(opts: {
+    series: LineSeries;
+    viewport: Viewport;
+    orientation: Orientation;
+    yAxisPosition: YAxisPosition;
+    xAxisPosition: XAxisPosition;
+    yAxisPadding: number;
+    gridDensity: "sparse" | "normal" | "dense";
+    axisVisible: boolean;
+    formatter: ChartFormatter;
+    secondarySeries: readonly SecondaryBarSeriesDraw[];
+    stackedLayout: StackingLayout | null;
+}): ChartLayout;
+/** Orientation-aware grid drawing. In horizontal mode, the role of
+ *  horizontal/vertical grid lines swaps: horizontal lines align with
+ *  category (slot) ticks, vertical lines align with value (numeric)
+ *  ticks. Both `drawGrid` axes now accept polymorphic tick shapes
+ *  - no per-draw `.map()` allocation. */
+export declare function drawBarChartGrid(args: {
+    ctx: CanvasRenderingContext2D;
+    layout: ChartLayout;
+    color: string;
+    width: number;
+    style: GridStyle;
+}): void;
+/** Orientation-aware axis drawing. The PHYSICAL axis sides
+ *  (`yAxisPosition` left/right, `xAxisPosition` top/bottom) stay the
+ *  same; what swaps is the CONTENT - which axis is value (numeric) and
+ *  which is category (time/slot). */
+export declare function drawBarChartAxes(args: {
+    ctx: CanvasRenderingContext2D;
+    layout: ChartLayout;
+    yAxisPosition: YAxisPosition;
+    xAxisPosition: XAxisPosition;
+    spineColor: string;
+    textColor: string;
+}): void;
+/** Static-layer draw: grid + axes + bars. The bar layer is the static
+ *  layer - repaints only on data / viewport / theme change, not per
+ *  pointer event. */
+export declare function drawFullBarChart(args: {
+    ctx: CanvasRenderingContext2D;
+    series: LineSeries;
+    layout: ChartLayout;
+    personalization: Personalization;
+    primaryColor: string | undefined;
+    secondarySeries: readonly SecondaryBarSeriesDraw[];
+    grouping: BarGrouping;
+    /** Pre-built layout for `'stacked'` grouping. Null = clustered. */
+    stackedLayout: StackingLayout | null;
+    yAxisPosition: YAxisPosition;
+    xAxisPosition: XAxisPosition;
+    gridVisible: boolean;
+    gridStyle: GridStyle;
+    axisVisible: boolean;
+    accents: boolean;
+    barWidthRatio: number;
+    groupPadding: number;
+    cornerRadius: number;
+    borderWidth: number;
+    valueLabels: ResolvedLabelConfig | null;
+    formatter: ChartFormatter;
+}): void;
+/** Dynamic-layer draw - crosshair + per-series snap markers. Cleared
+ *  and redrawn each pointer move (dynamic layer is the "high-frequency
+ *  repaint" surface, separate from the static layer that holds bars +
+ *  axes). */
+export declare function drawBarChartDynamicLayer(h: ChartHandle, hover: HoverState | null, cfg: DynamicCfg): void;
+export declare function defaultAriaLabel(series: LineSeries): string;