@abdullahjaswal/tickyr-charts-solid 0.1.0

package/dist/interaction/keyboard.d.ts

@@ -0,0 +1,16 @@
+export type KeyboardIntent = "pan-left" | "pan-right" | "pan-up" | "pan-down" | "zoom-in" | "zoom-out" | "reset-zoom" | "reset-domain" | "go-end" | "escape";
+/** Translate a `KeyboardEvent.key` into an intent. Returns `null` when
+ *  the key isn't bound (caller passes through). */
+export declare function intentFromKey(key: string): KeyboardIntent | null;
+export interface KeyboardHandlerOptions {
+    /** Called with the resolved intent. Caller decides which intents to
+     *  honor (e.g. ScatterChart ignores `go-end` since it has no time axis). */
+    readonly onIntent: (intent: KeyboardIntent, ev: KeyboardEvent) => void;
+    /** When `true` (default), the handler calls `preventDefault()` on the
+     *  bound keys so the browser doesn't scroll. */
+    readonly preventDefault?: boolean;
+}
+/** Build a keyboard listener that funnels mapped keys into `onIntent`.
+ *  Unmapped keys pass through (no preventDefault). Returns a function
+ *  the caller can `removeEventListener` to dispose. */
+export declare function makeKeyboardHandler(opts: KeyboardHandlerOptions): (ev: KeyboardEvent) => void;

package/dist/interaction/touch.d.ts

@@ -0,0 +1,27 @@
+/** Heuristic - when `true`, treat the device as primarily touch
+ *  (collapses crosshair to pin-on-click, opt-in pinch zoom, etc.). */
+export declare function detectTouchOnly(): boolean;
+export type LongPressBehavior = "crosshair" | "context-menu" | "none";
+export declare const DEFAULT_LONG_PRESS_BEHAVIOR: LongPressBehavior;
+export interface PinchEvent {
+    /** Scale ratio relative to the gesture start (`1 = no change`,
+     *  `>1 = zoom in`, `<1 = zoom out`). */
+    readonly scale: number;
+    /** Midpoint of the two pointers, in CSS px on the host element. */
+    readonly centerX: number;
+    readonly centerY: number;
+}
+export interface PinchHandlerOptions {
+    readonly onPinch: (ev: PinchEvent) => void;
+    readonly onPinchEnd?: () => void;
+}
+export interface PinchHandler {
+    onPointerDown(ev: PointerEvent): void;
+    onPointerMove(ev: PointerEvent): void;
+    onPointerUp(ev: PointerEvent): void;
+    /** Force-clear the active gesture (e.g. on unmount). */
+    dispose(): void;
+}
+/** Build a pinch handler. Tracks active pointers and emits scale deltas
+ *  on every pointermove during a two-finger gesture. */
+export declare function makePinchHandler(opts: PinchHandlerOptions): PinchHandler;

package/dist/perf/adaptive-complexity.d.ts

@@ -0,0 +1,45 @@
+export type FastModeInput = boolean | "auto";
+export interface FastModeContext {
+    /** From `navigator.connection.effectiveType` if present. */
+    readonly effectiveType?: string;
+    /** From `navigator.deviceMemory` (GB). */
+    readonly deviceMemory?: number;
+    /** From `matchMedia('(prefers-reduced-motion: reduce)').matches`. */
+    readonly prefersReducedMotion?: boolean;
+}
+/** Translate `fastMode: 'auto'` into a concrete boolean using the
+ *  context. Three triggers:
+ *    - effectiveType is "slow-2g" / "2g"
+ *    - deviceMemory ≤ 2 GB
+ *    - prefersReducedMotion is set
+ *  Any one trigger flips fastMode on. */
+export declare function resolveFastModeAuto(input: FastModeInput | undefined, ctx: FastModeContext): boolean;
+/** Detect the FastModeContext from `navigator` + `matchMedia`. Safe to
+ *  call during SSR (returns an empty context). */
+export declare function detectFastModeContext(): FastModeContext;
+export type DowngradeLevel = 0 | 1 | 2 | 3;
+export declare class FrameTimeMonitor {
+    private buf;
+    private idx;
+    private filled;
+    private level;
+    /** Cooldown counter - frames since the last level change. Prevents
+     *  the monitor from chasing its tail and downgrading multiple levels
+     *  in successive frames. */
+    private cooldown;
+    /** Record one frame's duration (ms). Returns the (possibly new) downgrade
+     *  level. Caller checks against the previous level to decide whether to
+     *  bust caches / re-render. */
+    recordFrame(ms: number): DowngradeLevel;
+    /** Current downgrade level (caller reads to apply to render config). */
+    currentLevel(): DowngradeLevel;
+    reset(): void;
+    private computeP95;
+}
+/** Map a downgrade level to the render config the chart should apply. */
+export interface RenderConfigOverrides {
+    readonly disableGlow: boolean;
+    readonly disableAnimations: boolean;
+    readonly capDpr: boolean;
+}
+export declare function downgradeOverrides(level: DowngradeLevel): RenderConfigOverrides;

package/dist/perf/memory-pressure.d.ts

@@ -0,0 +1,16 @@
+type Listener = () => void;
+/** Register a callback that fires whenever `notifyMemoryPressure()` is
+ *  called. Returns an unsubscribe function. Caches register at module
+ *  load time. Order of dispatch is registration order. */
+export declare function onMemoryPressure(cb: Listener): () => void;
+/** Fire all registered listeners. Hosts call this when the platform
+ *  signals memory pressure (e.g. iOS `didReceiveMemoryWarning` bridged
+ *  through to web, or a manual host-side throttle). The lib also calls
+ *  it internally from the visibility helper when a chart returns from
+ *  > 5 minutes of background time (TODO - wire from VisibilityGate). */
+export declare function notifyMemoryPressure(): void;
+/** Test-only - current listener count. */
+export declare function memoryPressureListenerCount(): number;
+/** Test-only - drop all listeners. */
+export declare function resetMemoryPressureListenersForTests(): void;
+export {};

package/dist/perf/offscreen-canvas-host.d.ts

@@ -0,0 +1,32 @@
+import { OffscreenContext } from './offscreen-canvas';
+/** Returns `true` if this chart's workload + the runtime should route
+ *  through the worker. Mirrors `shouldEngageOffscreenWorker` with the
+ *  additional gates that the worker can actually be constructed and
+ *  the canvas can transfer control. */
+export declare function canEngageOffscreenWorker(canvas: HTMLCanvasElement, ctx: OffscreenContext): boolean;
+export interface PaintRequest {
+    canvas: HTMLCanvasElement;
+    dpr: number;
+    cssWidth: number;
+    cssHeight: number;
+    times: Float64Array;
+    values: Float64Array;
+    /** Stroke / fill / line-width - anything that affects rendered
+     *  pixels. Serialized into the postMessage clone. */
+    payload: Record<string, unknown>;
+}
+/** Dispatch a paint to the worker. Returns `true` on success, `false`
+ *  when the host should fall back to main-thread rendering (worker
+ *  unavailable, transfer failed, etc.). The function does NOT throw -
+ *  errors decay to `false` so the caller's fallback path stays simple. */
+export declare function tryPaintWithWorker(req: PaintRequest): boolean;
+/** Tear down the worker globally. Charts call this on dispose if they
+ *  were the last consumer; the next `tryPaintWithWorker` re-spawns. */
+export declare function tearDownOffscreenWorker(): void;
+/** Recent paint frame times reported by the worker - caller can fold
+ *  into adaptive-complexity heuristics. */
+export declare function recentWorkerFrameMs(): readonly number[];
+/** For tests + the memory-pressure dispatcher - clear the recent-
+ *  frame buffer + reset spawn-failed flag without terminating the
+ *  worker. */
+export declare function resetWorkerStats(): void;

package/dist/perf/offscreen-canvas.d.ts

@@ -0,0 +1,50 @@
+declare const BULK_BAR_THRESHOLD = 5000;
+declare const MULTI_CHART_THRESHOLD = 4;
+declare const VISIBLE_MARK_THRESHOLD = 50000;
+export interface OffscreenContext {
+    /** Total bars in the dataset. */
+    readonly bulkBarCount?: number;
+    /** Charts mounted on the same page sharing the engine. */
+    readonly mountedChartCount?: number;
+    /** Currently-visible marks (after downsampling). */
+    readonly visibleMarkCount?: number;
+    /** Honor host opt-outs (e.g. SSR snapshot mode). */
+    readonly disabled?: boolean;
+}
+/** Should the chart engage the offscreen-worker render path? */
+export declare function shouldEngageOffscreenWorker(ctx: OffscreenContext): boolean;
+export { BULK_BAR_THRESHOLD, MULTI_CHART_THRESHOLD, VISIBLE_MARK_THRESHOLD };
+/** Host → worker. The host transfers the `OffscreenCanvas` reference
+ *  once during `init`; subsequent paints reuse the same canvas. Numeric
+ *  buffers are transferable typed arrays. */
+export type WorkerInput = {
+    readonly kind: "init";
+    readonly canvas: OffscreenCanvas;
+    readonly dpr: number;
+} | {
+    readonly kind: "resize";
+    readonly cssWidth: number;
+    readonly cssHeight: number;
+    readonly dpr: number;
+} | {
+    readonly kind: "paint";
+    readonly times: Float64Array;
+    readonly values: Float64Array;
+    readonly payload: Record<string, unknown>;
+} | {
+    readonly kind: "dispose";
+};
+/** Worker → host. The host updates UI based on these. */
+export type WorkerOutput = {
+    readonly kind: "ready";
+} | {
+    readonly kind: "painted";
+    readonly frameMs: number;
+} | {
+    readonly kind: "error";
+    readonly message: string;
+};
+/** Reusable transferable-list builder. Caller passes the typed arrays
+ *  whose backing buffers should be transferred (zero-copy), and we
+ *  return the `Transferable[]` array `postMessage` consumes. */
+export declare function transferablesFor(arrs: readonly ArrayBufferView[]): Transferable[];

package/dist/perf/offscreen-canvas.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/perf/shared-array-buffer.d.ts

@@ -0,0 +1,10 @@
+/** Is `SharedArrayBuffer` available + the page is cross-origin-isolated? */
+export declare function isSharedMemoryAvailable(): boolean;
+/** Allocate a Float64-backed buffer using `SharedArrayBuffer` when
+ *  available, falling back to a regular `Float64Array`. The returned
+ *  array's `.buffer` is `SharedArrayBuffer` in the fast path; callers
+ *  that want to be sure should check `.buffer instanceof SharedArrayBuffer`. */
+export declare function allocSharedFloat64(length: number): Float64Array;
+/** Allocate a Uint32-backed buffer using `SharedArrayBuffer` when
+ *  available, falling back to a regular `Uint32Array`. */
+export declare function allocSharedUint32(length: number): Uint32Array;

package/dist/perf/visibility.d.ts

@@ -0,0 +1,39 @@
+export interface VisibilitySource {
+    /** Current visibility state - true while page is visible AND element
+     *  is intersecting. */
+    isVisible(): boolean;
+    /** Subscribe to changes. Returns an unsubscribe function. The callback
+     *  fires AFTER `isVisible()` updates to its new value. */
+    onChange(cb: (visible: boolean) => void): () => void;
+    /** Tear down all observers + listeners. Idempotent. */
+    dispose(): void;
+}
+/** Higher-level helper that wraps a `VisibilitySource` + a single "the
+ *  chart wants to draw, but maybe later" deferral state. Static-draw
+ *  controllers (those without a persistent rAF loop) compose this so
+ *  the visibility wiring is a one-liner.
+ *
+ *  Usage in a controller:
+ *  ```ts
+ *  this.visGate = new VisibilityGate(opts.container ?? null, () => this.runStaticDraw())
+ *  // In runStaticDraw entry:  if (this.visGate.tryDefer()) return
+ *  // In dispose:               this.visGate.dispose()
+ *  ```
+ *  `tryDefer()` returns `true` when the chart is hidden - the caller
+ *  short-circuits its draw, and the gate re-runs the callback on the
+ *  next visibility wake. Returns `false` when visible - caller proceeds. */
+export declare class VisibilityGate {
+    private readonly onWake;
+    private readonly source;
+    private readonly unsubscribe;
+    private deferred;
+    private disposed;
+    constructor(container: HTMLElement | null, onWake: () => void);
+    /** Returns true when the chart is hidden - caller short-circuits its
+     *  draw. The gate remembers and will fire `onWake` when visibility
+     *  flips back to visible. */
+    tryDefer(): boolean;
+    isVisible(): boolean;
+    dispose(): void;
+}
+export declare function createChartVisibility(target: HTMLElement): VisibilitySource;

package/dist/perf/webgl-renderer.d.ts

@@ -0,0 +1,24 @@
+declare const GPU_ENGAGE_THRESHOLD = 50000;
+export type GpuRendererInput = "auto" | "on" | "off";
+export declare const DEFAULT_GPU_RENDERER: GpuRendererInput;
+export declare function resolveGpuRenderer(input: GpuRendererInput | undefined): GpuRendererInput;
+export interface GpuEngageContext {
+    /** Visible mark count after downsampling. */
+    readonly visibleMarkCount: number;
+    /** Host-resolved `gpuRenderer`. */
+    readonly gpuRenderer: GpuRendererInput;
+}
+/** Decide whether the chart should engage the WebGL2 renderer.
+ *  Returns false when WebGL2 is unavailable in this environment. */
+export declare function shouldEngageWebgl(ctx: GpuEngageContext): boolean;
+/** Cheap probe - returns true if `WebGL2RenderingContext` exists in the
+ *  current realm. Doesn't actually allocate a context. */
+export declare function isWebgl2Available(): boolean;
+/** Try to obtain a WebGL2 context. Wraps the `getContext` call in
+ *  try/catch + reports `null` on any error so the chart can fall back
+ *  to canvas2d without crashing. */
+export declare function tryGetWebgl2(canvas: HTMLCanvasElement): WebGL2RenderingContext | null;
+/** Compile + link a shader program with try/catch - returns `null` on
+ *  failure so the caller can fall back to canvas2d. */
+export declare function compileShaderProgram(gl: WebGL2RenderingContext, vsSource: string, fsSource: string): WebGLProgram | null;
+export { GPU_ENGAGE_THRESHOLD };

package/dist/perf/wire-memory-pressure.d.ts

@@ -0,0 +1,2 @@
+/** Idempotent - calling more than once is a no-op. */
+export declare function wireBuiltInMemoryPressureClears(): void;

package/dist/personalization/accessibility.d.ts

@@ -0,0 +1,16 @@
+export type ChartKind = "line" | "area" | "candle" | "bar" | "renko" | "kagi" | "pnf" | "pie" | "donut" | "treemap" | "sunburst" | "heatmap" | "histogram" | "scatter" | "depth" | "sankey";
+/** Default `aria-label` template. Concise + readable; hosts
+ *  override via `ariaLabel` prop when they have more context. */
+export declare function defaultAriaLabel(opts: {
+    readonly kind: ChartKind;
+    readonly seriesCount?: number;
+    readonly markCount?: number;
+    readonly symbol?: string;
+}): string;
+/** Apply ARIA attributes to a canvas host element. Idempotent - safe to
+ *  call on every render. */
+export declare function applyAriaAttributes(el: HTMLElement | undefined, opts: {
+    readonly label: string;
+    readonly role?: "img" | "figure";
+    readonly description?: string;
+}): void;

package/dist/personalization/axes/animation.d.ts

@@ -0,0 +1,33 @@
+export type BarEntryAnimation = "none" | "spring" | "fade" | "fade-stagger-left" | "fade-stagger-right" | "grow-from-baseline" | "rise-from-low" | "slide-from-right" | "slide-from-top" | "scale" | "expand-x" | "wave" | "wipe" | "random-fade";
+export type BarUpdateAnimation = "none" | "morph + flash-direction" | "morph" | "flash-neutral" | "flash-direction" | "pulse" | "glow" | "tick-line" | "flicker" | "rise";
+export type ThemeSwitchTransition = "fade" | "none";
+export interface AnimationAxes {
+    barEntryAnimation: BarEntryAnimation;
+    barUpdateAnimation: BarUpdateAnimation;
+    /** ms ≥ 0; clamps to 0 under reduced-motion. */
+    crosshairFadeDuration: number;
+    /** ms ≥ 0; clamps to 0 under reduced-motion. */
+    tooltipFadeDuration: number;
+    panZoomSmoothing: boolean;
+    themeSwitchTransition: ThemeSwitchTransition;
+}
+export declare const ANIMATION_DEFAULTS: AnimationAxes;
+export interface AnimationInputs {
+    barEntryAnimation?: BarEntryAnimation;
+    barUpdateAnimation?: BarUpdateAnimation;
+    crosshairFadeDuration?: number;
+    tooltipFadeDuration?: number;
+    panZoomSmoothing?: boolean;
+    themeSwitchTransition?: ThemeSwitchTransition;
+}
+export declare function resolveAnimation(input: AnimationInputs, reducedMotion: boolean): AnimationAxes;
+/** Total entry-animation duration (cap 600ms). Stagger
+ *  presets per-bar window is 220ms but total wall-clock cap is 600ms. */
+export declare const ENTRY_DURATION_CAP_MS = 600;
+export declare const ENTRY_STAGGER_PER_BAR_MS: number;
+export declare const UPDATE_DURATION_DEFAULT_MS = 250;
+export declare const PULSE_DURATION_MS = 250;
+export declare const GLOW_DURATION_MS = 500;
+export declare const TICK_LINE_DURATION_MS = 600;
+export declare const FLICKER_DURATION_MS = 400;
+export declare const RISE_DURATION_MS = 350;

package/dist/personalization/axes/area-baseline.d.ts

@@ -0,0 +1,8 @@
+export type AreaBaseline = "zero" | "first-value" | "last-value" | "min" | "max" | "mean" | "average" | "median" | number | ((window: Float64Array) => number);
+export interface ResolveAreaBaselineArgs {
+    readonly baseline: AreaBaseline;
+    readonly values: Float64Array;
+    readonly startIdx: number;
+    readonly endIdx: number;
+}
+export declare function resolveAreaBaseline(args: ResolveAreaBaselineArgs): number;

package/dist/personalization/axes/axis-labels.d.ts

@@ -0,0 +1,3 @@
+export type AxisLabelsMode = "both" | "x-only" | "y-only" | "none";
+export declare const DEFAULT_AXIS_LABELS: AxisLabelsMode;
+export declare function resolveAxisLabels(input: AxisLabelsMode | undefined): AxisLabelsMode;

package/dist/personalization/axes/bin-algorithm.d.ts

@@ -0,0 +1,3 @@
+export type BinAlgorithm = "sturges" | "freedman-diaconis" | "scott" | "fixed";
+export declare const DEFAULT_BIN_ALGORITHM: BinAlgorithm;
+export declare function resolveBinAlgorithm(input: BinAlgorithm | undefined): BinAlgorithm;

package/dist/personalization/axes/box-sizing.d.ts

@@ -0,0 +1,22 @@
+export type BoxSizingInput = number | `atr-${number}` | `percent-${number}` | {
+    readonly type: "fixed";
+    readonly value: number;
+} | {
+    readonly type: "atr";
+    readonly period: number;
+} | {
+    readonly type: "percent";
+    readonly value: number;
+};
+export type ResolvedBoxSizing = {
+    readonly type: "fixed";
+    readonly value: number;
+} | {
+    readonly type: "atr";
+    readonly period: number;
+} | {
+    readonly type: "percent";
+    readonly value: number;
+};
+export declare const DEFAULT_BOX_SIZING: ResolvedBoxSizing;
+export declare function resolveBoxSizing(input: BoxSizingInput | undefined): ResolvedBoxSizing;

package/dist/personalization/axes/cell-shape.d.ts

@@ -0,0 +1,3 @@
+export type CellShape = "rect" | "circle";
+export declare const DEFAULT_CELL_SHAPE: CellShape;
+export declare function resolveCellShape(input: CellShape | undefined): CellShape;

package/dist/personalization/axes/curve-type.d.ts

@@ -0,0 +1,11 @@
+import { CurveFactory } from 'd3-shape';
+export type CurveTypeName = "linear" | "monotone" | "monotone-x" | "monotone-y" | "step" | "step-before" | "step-after" | "bump" | "bump-x" | "bump-y" | "natural" | "basis" | "cardinal" | "catmull-rom";
+export interface CurveTypeConfig {
+    readonly type: CurveTypeName;
+    /** 0–1 - only honored for `cardinal`. Default 0. Higher = looser curve. */
+    readonly tension?: number;
+    /** 0–1 - only honored for `catmull-rom`. Default 0.5 (centripetal). */
+    readonly alpha?: number;
+}
+export type CurveType = CurveTypeName | CurveTypeConfig;
+export declare function resolveCurveFactory(curveType: CurveType, stepEdgeRadius: number): CurveFactory;

package/dist/personalization/axes/density.d.ts

@@ -0,0 +1,4 @@
+export type DensityInput = "off" | "auto" | "on";
+export type DensityRenderMode = "points" | "heatmap";
+export declare const DENSITY_AUTO_THRESHOLD = 50000;
+export declare function resolveDensityMode(input: DensityInput | undefined, pointCount: number): DensityRenderMode;

package/dist/personalization/axes/depth-fill-type.d.ts

@@ -0,0 +1,3 @@
+export type DepthFillType = "flat" | "gradient";
+export declare const DEFAULT_DEPTH_FILL_TYPE: DepthFillType;
+export declare function resolveDepthFillType(input: DepthFillType | undefined): DepthFillType;

package/dist/personalization/axes/depth-limit.d.ts

@@ -0,0 +1,2 @@
+export type DepthLimitInput = number | "all";
+export declare function resolveDepthLimit(input: DepthLimitInput | undefined): number;

package/dist/personalization/axes/glow.d.ts

@@ -0,0 +1,21 @@
+export type GlowPreset = "off" | "subtle" | "standard" | "intense";
+/** Host-supplied input. Named presets resolve to fixed strengths; numeric
+ *  values clamp to `[0, 1]`. */
+export type GlowInput = GlowPreset | number;
+/** `'auto'` (default) = each mark glows in its own direction color
+ *  (`up`/`down`/`doji` from the palette). A literal color (any CSS-color
+ *  string, hex, or `oklch(...)`) overrides for uniform brand glow. */
+export type GlowColorInput = "auto" | string;
+export interface ResolvedGlow {
+    /** Normalized strength 0..1. Zero means glow is off; the rendering
+     *  primitive short-circuits and avoids the offscreen pass entirely. */
+    readonly strength: number;
+    /** Direction-aware or literal. `'auto'` triggers direction resolution at
+     *  draw time using the chart's palette. */
+    readonly color: "auto" | string;
+}
+export declare const DEFAULT_GLOW: GlowInput;
+export declare const DEFAULT_GLOW_COLOR: GlowColorInput;
+/** Resolve glow inputs to a normalized form. `fastMode` forces strength
+ *  to zero regardless of input. */
+export declare function resolveGlow(input: GlowInput | undefined, color: GlowColorInput | undefined, fastMode: boolean): ResolvedGlow;

package/dist/personalization/axes/heatmap-color-scale.d.ts

@@ -0,0 +1,31 @@
+export type HeatmapColorScaleType = "sequential" | "diverging" | "qualitative";
+interface DivergingConfig {
+    readonly type: "diverging";
+    /** Value mapped to the neutral mid-point. Default 0. */
+    readonly midpoint?: number;
+    /** `[low, high]` data range. When omitted, auto-fits to the data's
+     *  symmetric extent at compute time. */
+    readonly domain?: readonly [number, number];
+}
+interface SequentialConfig {
+    readonly type: "sequential";
+    /** `[low, high]` data range. When omitted, auto-fits to data extent. */
+    readonly domain?: readonly [number, number];
+}
+interface QualitativeConfig {
+    readonly type: "qualitative";
+}
+export type HeatmapColorScaleInput = HeatmapColorScaleType | DivergingConfig | SequentialConfig | QualitativeConfig;
+export type ResolvedHeatmapColorScale = {
+    readonly type: "diverging";
+    readonly midpoint: number;
+    readonly domain: readonly [number, number] | null;
+} | {
+    readonly type: "sequential";
+    readonly domain: readonly [number, number] | null;
+} | {
+    readonly type: "qualitative";
+};
+export declare const DEFAULT_HEATMAP_COLOR_SCALE: HeatmapColorScaleType;
+export declare function resolveHeatmapColorScale(input: HeatmapColorScaleInput | undefined): ResolvedHeatmapColorScale;
+export {};

package/dist/personalization/axes/histogram-overlay.d.ts

@@ -0,0 +1,18 @@
+export type HistogramOverlayType = "normal" | "cumulative-line";
+interface OverlayStyle {
+    /** `'auto'` resolves to `palette.neutral` at draw time. */
+    readonly color?: "auto" | string;
+    readonly lineWidth?: number;
+    readonly lineDash?: readonly number[];
+}
+export type HistogramOverlayInput = false | "normal" | "cumulative-line" | (OverlayStyle & {
+    readonly type: HistogramOverlayType;
+});
+export interface ResolvedHistogramOverlay {
+    readonly type: HistogramOverlayType;
+    readonly color: "auto" | string;
+    readonly lineWidth: number;
+    readonly lineDash: readonly number[] | null;
+}
+export declare function resolveHistogramOverlay(input: HistogramOverlayInput | undefined): ResolvedHistogramOverlay | null;
+export {};

package/dist/personalization/axes/indicator-pane-spec.d.ts

@@ -0,0 +1,85 @@
+export type IndicatorLineStyle = "solid" | "dashed" | "dotted";
+export interface IndicatorPaneCommon {
+    /** `'auto'` resolves from `palette.indicators.<type>` at draw time. */
+    color?: "auto" | string;
+    /** Overrides global `indicatorLineWidth`. */
+    lineWidth?: number;
+    /** Overrides global `indicatorLineStyle`. */
+    lineStyle?: IndicatorLineStyle;
+    /** Overrides global `indicatorOpacity`. */
+    opacity?: number;
+}
+export interface RsiSpecInput extends IndicatorPaneCommon {
+    type: "rsi";
+    period?: number;
+    overbought?: number;
+    oversold?: number;
+}
+export interface MacdSpecInput extends IndicatorPaneCommon {
+    type: "macd";
+    fastPeriod?: number;
+    slowPeriod?: number;
+    signalPeriod?: number;
+    histogramVisible?: boolean;
+}
+export interface StochasticSpecInput extends IndicatorPaneCommon {
+    type: "stochastic";
+    kPeriod?: number;
+    dPeriod?: number;
+    smoothing?: number;
+    overbought?: number;
+    oversold?: number;
+}
+export interface AtrSpecInput extends IndicatorPaneCommon {
+    type: "atr";
+    period?: number;
+}
+export type IndicatorPaneSpec = RsiSpecInput | MacdSpecInput | StochasticSpecInput | AtrSpecInput;
+export interface ResolvedRsiSpec {
+    type: "rsi";
+    period: number;
+    overbought: number;
+    oversold: number;
+    color: "auto" | string;
+    lineWidth: number;
+    lineStyle: IndicatorLineStyle;
+    opacity: number;
+}
+export interface ResolvedMacdSpec {
+    type: "macd";
+    fastPeriod: number;
+    slowPeriod: number;
+    signalPeriod: number;
+    histogramVisible: boolean;
+    color: "auto" | string;
+    lineWidth: number;
+    lineStyle: IndicatorLineStyle;
+    opacity: number;
+}
+export interface ResolvedStochasticSpec {
+    type: "stochastic";
+    kPeriod: number;
+    dPeriod: number;
+    smoothing: number;
+    overbought: number;
+    oversold: number;
+    color: "auto" | string;
+    lineWidth: number;
+    lineStyle: IndicatorLineStyle;
+    opacity: number;
+}
+export interface ResolvedAtrSpec {
+    type: "atr";
+    period: number;
+    color: "auto" | string;
+    lineWidth: number;
+    lineStyle: IndicatorLineStyle;
+    opacity: number;
+}
+export type ResolvedIndicatorPaneSpec = ResolvedRsiSpec | ResolvedMacdSpec | ResolvedStochasticSpec | ResolvedAtrSpec;
+export interface IndicatorGlobalDefaults {
+    lineWidth: number;
+    lineStyle: IndicatorLineStyle;
+    opacity: number;
+}
+export declare function resolveIndicatorPaneSpec(spec: IndicatorPaneSpec, globals: IndicatorGlobalDefaults): ResolvedIndicatorPaneSpec;

package/dist/personalization/axes/label-behavior.d.ts

@@ -0,0 +1,3 @@
+export type LabelBehavior = "show-all" | "truncate" | "wrap" | "hide-on-overflow" | "auto";
+export declare const DEFAULT_LABEL_BEHAVIOR: LabelBehavior;
+export declare function resolveLabelBehavior(input: LabelBehavior | undefined): LabelBehavior;

package/dist/personalization/axes/label-content.d.ts

@@ -0,0 +1,17 @@
+export type LabelContentPreset = "name" | "value" | "percent" | "name + value" | "name + percent" | "all";
+export interface SliceLabelData {
+    readonly name: string;
+    readonly value: number;
+    /** 0–1 fraction of the total. */
+    readonly percent: number;
+}
+export type LabelContentInput = LabelContentPreset | ((slice: SliceLabelData) => string);
+export type ResolvedLabelContent = {
+    readonly kind: "preset";
+    readonly preset: LabelContentPreset;
+} | {
+    readonly kind: "function";
+    readonly fn: (slice: SliceLabelData) => string;
+};
+export declare const DEFAULT_LABEL_CONTENT: LabelContentPreset;
+export declare function resolveLabelContent(input: LabelContentInput | undefined): ResolvedLabelContent;

package/dist/personalization/axes/label-placement.d.ts

@@ -0,0 +1,3 @@
+export type LabelPlacement = "inside" | "outside" | "leader-line" | "auto" | "off";
+export declare const DEFAULT_LABEL_PLACEMENT: LabelPlacement;
+export declare function resolveLabelPlacement(input: LabelPlacement | undefined): LabelPlacement;

package/dist/personalization/axes/label-rotation.d.ts

@@ -0,0 +1,3 @@
+export type LabelRotation = "horizontal" | "radial" | "tangent" | "auto";
+export declare const DEFAULT_LABEL_ROTATION: LabelRotation;
+export declare function resolveLabelRotation(input: LabelRotation | undefined): LabelRotation;

package/dist/personalization/axes/level-highlight.d.ts

@@ -0,0 +1,14 @@
+interface LevelHighlightConfig {
+    /** `'auto'` resolves to `palette.warn` at draw time (visual urgency). */
+    readonly color?: "auto" | string;
+    readonly lineWidth?: number;
+    readonly lineDash?: readonly number[];
+}
+export type LevelHighlightInput = false | true | LevelHighlightConfig;
+export interface ResolvedLevelHighlight {
+    readonly color: "auto" | string;
+    readonly lineWidth: number;
+    readonly lineDash: readonly number[] | null;
+}
+export declare function resolveLevelHighlight(input: LevelHighlightInput | undefined): ResolvedLevelHighlight | null;
+export {};

package/dist/personalization/axes/line-dash.d.ts

@@ -0,0 +1,2 @@
+export type LineDash = "solid" | "dashed" | "dotted" | readonly number[];
+export declare function resolveLineDash(lineDash: LineDash, lineDashSpacing: number): number[];

package/dist/personalization/axes/mid-line.d.ts

@@ -0,0 +1,14 @@
+export type MidLineStyle = "solid" | "dashed";
+interface MidLineConfig {
+    readonly style?: MidLineStyle;
+    readonly color?: "auto" | string;
+    readonly lineWidth?: number;
+}
+export type MidLineInput = false | true | "dashed" | MidLineConfig;
+export interface ResolvedMidLine {
+    readonly style: MidLineStyle;
+    readonly color: "auto" | string;
+    readonly lineWidth: number;
+}
+export declare function resolveMidLine(input: MidLineInput | undefined): ResolvedMidLine | null;
+export {};

package/dist/personalization/axes/node-alignment.d.ts

@@ -0,0 +1,3 @@
+export type NodeAlignment = "justify" | "left" | "right" | "center";
+export declare const DEFAULT_NODE_ALIGNMENT: NodeAlignment;
+export declare function resolveNodeAlignment(input: NodeAlignment | undefined): NodeAlignment;