@luxalgo/vela 0.5.0

package/dist/plugin-D94muTV-.d.cts

@@ -0,0 +1,405 @@
+import { u as DrawingTypeKey, a3 as DrawingStyle, S as SerializedDrawing, D as Drawing, av as SeriesKind, O as OHLCV, c as VelaTheme } from './options-Q-576hIi.cjs';
+import { b as DataControl } from './contributions-o1GRKPI_.cjs';
+import './side-panel-CT9ZwIGz.cjs';
+import './icons-BZYbJXSV.cjs';
+import './keymap-CGOz5F5f.cjs';
+import './DataProvider-DKNDHpNv.cjs';
+
+/** What a drawing type contributes to the toolbar + factory (renderer-neutral). */
+interface DrawingTypeMeta {
+    type: DrawingTypeKey;
+    /** Toolbar group id (e.g. `'lines'`, `'shapes'`, `'annotations'`). */
+    group: string;
+    label: string;
+    /** Inline SVG markup for the toolbar button — no DOM, renderer paints it. */
+    icon: string;
+    defaultStyle: DrawingStyle;
+    /** Build an instance from a (partial) serialized record. Serves create + deserialize. */
+    create(init: Partial<SerializedDrawing> & {
+        paneId: string;
+    }): Drawing;
+}
+/** Register (or replace) a drawing type. Built-ins register at module load; new
+ *  types (fibs/patterns) call this — no base/port/facade change. */
+declare function registerDrawingType(meta: DrawingTypeMeta): void;
+declare function getDrawingType(type: string): DrawingTypeMeta | undefined;
+declare function drawingTypes(): DrawingTypeMeta[];
+/** Build a fresh drawing of `type` on `paneId`, seeding the type's default style. */
+declare function createDrawing(type: DrawingTypeKey, init: Partial<SerializedDrawing> & {
+    paneId: string;
+}): Drawing | null;
+/** Rehydrate a {@link Drawing} from a plain record, or null for an unknown type. */
+declare function deserializeDrawing(doc: SerializedDrawing): Drawing | null;
+
+/**
+ * The authoritative, user-controlled pan/zoom state of the time axis.
+ *
+ * - `barSpacing`: pixels between adjacent bar centers (the zoom level).
+ * - `rightOffset`: how many bar-widths the LAST bar sits from the right edge
+ *   (the pan position). May be negative (last bar scrolled off the right).
+ *
+ * The chart width and bar count are NOT part of this state — they are owned by
+ * the renderer (resize / setBars) and combined with the viewport in the
+ * CoordinateSystem to produce pixel coordinates.
+ */
+interface ViewportState {
+    barSpacing: number;
+    rightOffset: number;
+}
+
+/** A pane's price window (after autoscale + margins). `log` ⇒ logarithmic mapping;
+ *  `invert` ⇒ the axis is flipped (high at the bottom), stamped per frame from the pane. */
+interface PriceScale {
+    min: number;
+    max: number;
+    log?: boolean;
+    invert?: boolean;
+}
+/** A pane's vertical pixel extent within the chart's data area (media px). */
+interface PaneBounds {
+    top: number;
+    height: number;
+}
+/**
+ * The ONE authoritative coordinate transform, shared by every layer (data
+ * backend, canvas2d chrome, DOM overlays). Two decoupled axes:
+ *
+ * - X: a fractional **logical bar index** mapped to pixels by the viewport
+ *   (`barSpacing` + `rightOffset`); bar TIME ↔ logical is a separate mapping
+ *   over the loaded bar times so time and spacing stay independent.
+ * - Y: a per-pane **linear/log/percent price** mapped within that pane's bounds.
+ *
+ * Everything is in media (CSS) pixels; `toBitmap` converts to device pixels for
+ * crisp drawing. Keeping a single instance is what keeps all layers aligned.
+ */
+declare class CoordinateSystem {
+    private widthPx;
+    private dataHeightPx;
+    private devicePixelRatio;
+    private viewport;
+    private pitchScale;
+    private times;
+    private intervalMs;
+    setSize(width: number, dataHeight: number, dpr: number): void;
+    setBars(times: readonly number[]): void;
+    /**
+     * Append one new bar time in O(1). The bar cadence is stable, so the median
+     * interval is NOT re-derived (a full re-sort per live tick would be O(n log n)).
+     * It's only derived lazily — via the robust median over the bars seen so far —
+     * while it's still unknown (cold start at <2 bars); the warm path is a single
+     * push. `barCount` reads `times.length`, so the new bar is visible immediately.
+     */
+    appendBar(time: number): void;
+    setViewport(viewport: ViewportState): void;
+    getViewport(): ViewportState;
+    /**
+     * Spacing multiplier applied to the center-to-center pixel PITCH between adjacent
+     * bars (and hence the crosshair's snap step) — independent of the zoom (`barSpacing`).
+     * `1` = default; `>1` spreads bars apart with real gaps; `<1` tightens them. It changes
+     * only where bars SIT (`logicalToX`/`xToLogical`), never their raw zoom value, so candle
+     * bodies keep their width — the extra pitch becomes gap. Body width tracks
+     * {@link bodySpacing} so a `<1` multiplier shrinks bodies to fit instead of overlapping.
+     */
+    setPitchScale(scale: number): void;
+    get spacingScale(): number;
+    /** Effective center-to-center pixel pitch between adjacent bars (zoom × spacing multiplier). */
+    pxPerBar(): number;
+    /**
+     * Pixel basis for element (candle/bar/column) BODY width. Kept at the raw zoom pitch so
+     * bodies keep their width while the multiplier only adds gap; capped at the effective pitch
+     * so a `<1` multiplier tightens bodies to fit rather than overlapping the neighbours.
+     */
+    bodySpacing(): number;
+    get width(): number;
+    get height(): number;
+    get dpr(): number;
+    get barCount(): number;
+    get barInterval(): number;
+    /** The logical index that sits exactly at the right pixel edge of the chart. */
+    get rightEdgeLogical(): number;
+    logicalToX(logical: number): number;
+    xToLogical(x: number): number;
+    timeToLogical(ms: number): number;
+    logicalToTime(logical: number): number;
+    timeToX(ms: number): number;
+    priceToY(price: number, scale: PriceScale, bounds: PaneBounds): number;
+    yToPrice(y: number, scale: PriceScale, bounds: PaneBounds): number;
+    visibleLogicalRange(): {
+        from: number;
+        to: number;
+    };
+    visibleTimeRange(): {
+        from: number;
+        to: number;
+    };
+    toBitmap(mediaPx: number): number;
+}
+
+/** Things that need a stable id within an indicator instance. */
+type IdentifiableKind = SeriesKind | 'fill' | 'background' | 'hline' | 'line' | 'box' | 'label' | 'polyline' | 'linefill' | 'table';
+/**
+ * Content-addressed id for a plotted element, stable across re-runs of
+ * identical source.
+ *
+ * Deliberately NOT an engine's own callsite counter: those renumber whenever the
+ * source is edited (insert a plot near the top and every downstream callsite
+ * shifts), so keying persistent state on one would silently rebind to the wrong
+ * element. The ordinal disambiguates multiple plots that share a title within one
+ * indicator. Every engine MUST mint its series ids through this — it is the
+ * identity contract value patches are keyed by.
+ */
+declare function stableSeriesId(parts: {
+    instanceId: string;
+    kind: IdentifiableKind;
+    title: string;
+    ordinal: number;
+}): string;
+
+/**
+ * A 1:1, TIME-PRESERVING per-bar transform a price style applies to the chart's bar
+ * stream (Heikin Ashi is the first). The orchestrator applies it at its single outbound
+ * bar seam, so the renderer, the scripting engines, and the native indicators all see
+ * one consistent VIEW while the raw series stays the untouched source of truth (the
+ * `'bar'` event and `chart.data` stay on the raw plane).
+ *
+ * Deliberately NOT a contract for styles that change the bar count or time axis
+ * (Renko, Kagi, Point & Figure) — those need a different seam.
+ */
+interface BarTransform {
+    /** Derive the full view series from the raw series (front-to-back; may be recursive). */
+    full(raw: readonly OHLCV[]): OHLCV[];
+    /** Derive ONE view bar from a raw bar + the PREVIOUS view bar (live tick / append; O(1)). */
+    next(raw: OHLCV, prevView: OHLCV | undefined): OHLCV;
+}
+
+/** The environment a chart hands to a style's data engine when the style activates. */
+interface SeriesDataEngineHost {
+    /** The chart's symbol (as configured, provider prefix stripped by the data layer). */
+    symbol: string;
+    /** The chart's timeframe (canonical string, e.g. `'60'`). */
+    timeframe: string;
+    /** Whether the chart runs live (streaming forming bar) or static history. */
+    live: boolean;
+    /** The chart's CURRENT view bars (post-transform) — read fresh, never cache. */
+    bars: () => readonly OHLCV[];
+    /** The chart's data control surface (`chart.data`) — providers, capabilities, resolution. */
+    data: DataControl;
+    /** Push the style's per-bar layer data to the renderer (the `<id>` native channel). */
+    pushData: (data: unknown) => void;
+    /** Push the ranges still loading (the `<id>-pending` channel — skeleton/reveal UIs). */
+    pushPending: (ranges: ReadonlyArray<readonly [number, number]>) => void;
+}
+/**
+ * A per-chart data engine behind a chart type: created on first entry into the style,
+ * suspended/resumed as the user switches styles, stopped when the chart is destroyed.
+ * All methods are fire-and-forget from the chart's point of view — the engine owns its
+ * own scheduling and pushes results through the host channels.
+ */
+interface SeriesDataEngine {
+    start(host: SeriesDataEngineHost): void;
+    /** The style was left — stop fetching/pushing, keep state for a cheap resume. */
+    suspend(): void;
+    /** The style was re-entered. */
+    resume(): void;
+    /** The chart is going away — release everything. */
+    stop(): void;
+    /** The visible range changed (pan/zoom) while the style is active. */
+    onViewport?(range: {
+        from: number;
+        to: number;
+    }): void;
+    /** New settings values from the chart-settings dialog (the type's SDK section). */
+    onSettings?(values: Record<string, unknown>): void;
+}
+/** One registered chart type. */
+interface ChartTypeDefinition {
+    /** The price-style id (`'heikinashi'`; a plugin might register `'footprint'`, `'renko'`…). */
+    id: string;
+    /** Human-readable label for style pickers. Defaults to the id. */
+    label?: string;
+    /** Raw `<svg>` markup for style pickers (surfaced as icon id `style-<id>`). */
+    icon?: string;
+    /** Optional SETTINGS SECTION rendered inside the chart-settings dialog — declarative
+     *  rows (never DOM). Values persist in the renderer config under `chartTypes.<id>`
+     *  and are pushed to the type's `<id>-settings` native-data channel on change. */
+    settings?: ChartTypeSettingsSection;
+    /** View-bar transform applied at the chart's outbound bar seam (1:1, time-preserving). */
+    barTransform?: BarTransform;
+    /**
+     * Whether the type participates in extended tickers (`"SYM;id"` — scripts request the
+     * transformed series via `ticker.*`). Defaults to `true` when `barTransform` is set:
+     * a transform-based type is exactly what the data plane can re-derive server-side.
+     */
+    tickerModifier?: boolean;
+    /** Factory for the style's per-chart data engine (created lazily on first activation). */
+    dataEngine?: () => SeriesDataEngine;
+    /**
+     * What the renderer paints for the PRICE SERIES while this style is active.
+     * `'candles'` (default) keeps the base candle painting under the type's layers;
+     * `'none'` suppresses it — for types whose renderer layer fully REPLACES the
+     * price representation (an order-flow grid, bricks, …). Axes, grid, volume,
+     * indicators and drawings are unaffected.
+     */
+    basePainting?: 'candles' | 'none';
+}
+/** One declarative settings row. To add a NEW kind, see docs/architecture/settings-rows.md. */
+type SettingsRowDescriptor = {
+    kind: 'toggle';
+    key: string;
+    label: string;
+    defval: boolean;
+} | {
+    kind: 'number';
+    key: string;
+    label: string;
+    defval: number;
+    min?: number;
+    max?: number;
+    step?: number;
+} | {
+    kind: 'color';
+    key: string;
+    label: string;
+    defval: string;
+} | {
+    kind: 'select';
+    key: string;
+    label: string;
+    options: readonly string[];
+    defval: string;
+};
+interface ChartTypeSettingsSection {
+    /** Section heading in the settings dialog. */
+    title: string;
+    rows: readonly SettingsRowDescriptor[];
+    /** `'active'` (default): shown only while this chart type is the active price style;
+     *  `'always'`: shown whenever the type is registered. */
+    visibility?: 'always' | 'active';
+}
+/** Register (or replace) a chart type. */
+declare function registerChartType(def: ChartTypeDefinition): void;
+/** Remove a registered chart type (built-ins can be re-registered via their register fn). */
+declare function unregisterChartType(id: string): void;
+/** The definition behind a price-style id, or undefined for built-ins/unknown ids. */
+declare function chartType(id: unknown): ChartTypeDefinition | undefined;
+/** Every registered chart type (registration order). */
+declare function chartTypes(): ChartTypeDefinition[];
+/** Ids that act as extended-ticker modifiers (`"SYM;id"`). */
+declare function tickerModifierIds(): string[];
+
+/**
+ * Register default values for renderer features — every chart built afterwards applies
+ * them once its renderer is mounted, before the first paint. Keys are renderer feature
+ * names (`chart.renderer.features`); one the active renderer does not support is warned
+ * about and ignored, exactly as `renderer.set()` does.
+ *
+ * These are DEFAULTS, not locks: an explicit `chart.renderer.set(...)`, an applied config
+ * template, or the user's own in-chart settings still win afterwards. Charts already
+ * built are untouched. Returns a disposer that removes precisely the values it set
+ * (leaving any later re-registration of the same key in place).
+ */
+declare function registerRendererDefaults(values: Record<string, unknown>): () => void;
+/** Drop registered defaults by key — all of them when called with no arguments. */
+declare function unregisterRendererDefaults(...keys: string[]): void;
+/** The defaults a chart applies at construction (empty when no plugin registered any). */
+declare function rendererDefaults(): Record<string, unknown>;
+
+/** Everything a layer needs to paint one frame. */
+interface RendererLayerArgs {
+    /** The chart's CURRENT view bars (post bar-transform). */
+    bars: readonly OHLCV[];
+    /** The layer's channel payload (last `setNativeData(id, …)` push; undefined before the first). */
+    data: unknown;
+    /** The type's SDK settings values (`<id>-settings` channel; {} before any edit). */
+    settings: Record<string, unknown>;
+    /** Time ranges still loading (`<id>-pending` channel) — skeleton/reveal UIs. */
+    pending: ReadonlyArray<readonly [number, number]>;
+    coords: CoordinateSystem;
+    /** The price pane's scale + bounds. */
+    scale: PriceScale;
+    bounds: PaneBounds;
+    theme: VelaTheme;
+    /** The active price style — layers tied to a chart type gate their visibility on it. */
+    priceStyle: string;
+    /** Frame clock (ms) for pulses/fades; monotonic within a session. */
+    nowMs: number;
+}
+/** One live layer instance (per mounted renderer). */
+interface RendererLayerInstance {
+    /** The renderer created (and owns) this transparent canvas — keep the reference, paint into it. */
+    mount(canvas: HTMLCanvasElement): void;
+    /** Paint one frame. Always clear/redraw your own canvas — the renderer never clears it for you. */
+    render(args: RendererLayerArgs): void;
+    /** Return true while the layer needs CONTINUOUS frames (a pulse/fade) — keeps the animator alive. */
+    animating?(): boolean;
+    /** The renderer unmounted — release everything (the canvas itself is removed by the renderer). */
+    destroy?(): void;
+}
+/** One registered layer kind. */
+interface RendererLayerDefinition {
+    /** The layer id — also its native-data channel (`setNativeData(id, …)` / `id + '-pending'`). */
+    id: string;
+    /** Stacking: `'below-data'` = behind the candles (reveal-under styles); `'above-data'` =
+     *  over the candles, under the chrome/axes. Default `'above-data'`. */
+    placement?: 'below-data' | 'above-data';
+    /** Instance factory — called once per mounted renderer. */
+    create(): RendererLayerInstance;
+}
+/** Register (or replace) a renderer layer. Renderers mounted AFTER registration pick it up. */
+declare function registerRendererLayer(def: RendererLayerDefinition): void;
+declare function unregisterRendererLayer(id: string): void;
+/** Every registered layer definition (registration order). */
+declare function rendererLayers(): RendererLayerDefinition[];
+
+/** Selection/menu accent — active entries, "native" badges, selected controls. */
+declare const ACCENT = "#2962ff";
+/** The lighter brand blue: "on" affordances and the default drawing color, brighter than
+ *  {@link ACCENT} so a switch reads clearly enabled. */
+declare const ACCENT_BRIGHT = "#38c0fd";
+/** Bullish/bearish reference pair — the dark theme's candle colors, reused wherever a
+ *  fixed directional color is needed outside a theme (volume profiles, baseline defaults). */
+declare const BULLISH = "#089981";
+declare const BEARISH = "#f23645";
+/** Neutral gray for de-emphasized geometry (unstyled level lines, gann 1/1 diagonals). */
+declare const NEUTRAL = "#787b86";
+/** Attention amber — favorited items. */
+declare const HIGHLIGHT = "#e0b400";
+/** Warm accent used by the categorical palette and warning-ish marks. */
+declare const WARNING = "#ff9800";
+/** Soft informational blue — statistical overlays (regression, VWAP) and the blue rung of the
+ *  drawing level palette, which should read as derived data rather than user-drawn geometry. */
+declare const INFO = "#5b9cf6";
+/** Highlighter ink — a saturated marker orange, always drawn translucent. */
+declare const MARKER = "#ff5d00";
+/** Validity tints — a pattern that satisfies its rules vs one that does not. Brighter and
+ *  cooler than {@link BULLISH}/{@link BEARISH} so a validity wash never reads as direction. */
+declare const VALID = "#0ecb81";
+declare const INVALID = "#f6465d";
+/** Market-session states beside the theme's up-colored "open": pre-market dawn amber,
+ *  post-market dusk sky, and the shared closed/holiday gray (statusline badge). */
+declare const SESSION_PRE = "#f97316";
+declare const SESSION_POST = "#0ea5e9";
+declare const SESSION_OFF = "#9ca3af";
+/** Default color of a plain line/area series — a softer blue than {@link ACCENT}, which is
+ *  reserved for interactive chrome. */
+declare const SERIES_LINE = "#3b82f6";
+/** Crosshair ink: a cool gray that stays legible over both candles and empty surface. */
+declare const CROSSHAIR = "#9aa0ad";
+/** Fixed slate plates for canvas chrome that floats over chart content of any color
+ *  (crosshair value chips, info badges) — they cannot follow the theme surface and stay
+ *  readable. `SLATE_DEEP` is the plate, `SLATE` its border. */
+declare const SLATE_DEEP = "#1e293b";
+declare const SLATE = "#475569";
+/** Strategy trade markers — entry arrows per position side, and the exits' shared violet.
+ *  The entry pair deliberately reuses the accent blue / bearish red (the reference palette
+ *  of order-fill marks); the violet keeps exits apart from both directions. */
+declare const TRADE_LONG = "#2962ff";
+declare const TRADE_SHORT = "#f23645";
+declare const TRADE_EXIT = "#d500f9";
+/** Categorical hues for auto-assigned colors (symbol badges, multi-series defaults).
+ *  Ordered for adjacent-hue contrast, not by hue family. */
+declare const CATEGORICAL: readonly string[];
+/** Pick a stable categorical color for a string key (same key ⇒ same color). */
+declare function categoricalColor(key: string): string;
+
+export { ACCENT as A, BEARISH as B, CATEGORICAL as C, type DrawingTypeMeta as D, getDrawingType as E, registerChartType as F, registerDrawingType as G, HIGHLIGHT as H, INFO as I, registerRendererDefaults as J, registerRendererLayer as K, rendererDefaults as L, MARKER as M, NEUTRAL as N, rendererLayers as O, stableSeriesId as P, tickerModifierIds as Q, type RendererLayerArgs as R, SERIES_LINE as S, TRADE_EXIT as T, unregisterChartType as U, VALID as V, WARNING as W, unregisterRendererDefaults as X, unregisterRendererLayer as Y, ACCENT_BRIGHT as a, BULLISH as b, type BarTransform as c, CROSSHAIR as d, type ChartTypeDefinition as e, type ChartTypeSettingsSection as f, INVALID as g, type IdentifiableKind as h, type RendererLayerDefinition as i, type RendererLayerInstance as j, SESSION_OFF as k, SESSION_POST as l, SESSION_PRE as m, SLATE as n, SLATE_DEEP as o, type SeriesDataEngine as p, type SeriesDataEngineHost as q, type SettingsRowDescriptor as r, TRADE_LONG as s, TRADE_SHORT as t, categoricalColor as u, chartType as v, chartTypes as w, createDrawing as x, deserializeDrawing as y, drawingTypes as z };