wickchart 0.3.0

package/types/hab-chart.d.ts

@@ -0,0 +1,377 @@
+declare const HTMLElementBase: {
+    new (): {};
+};
+declare class HabChart extends HTMLElementBase {
+    _canvas: any;
+    _ctx: any;
+    _legend: any;
+    _hud: any;
+    _poss: any;
+    _statsRow: any;
+    _nodata: any;
+    _data: any[];
+    _version: number;
+    _view: {
+        rightIndex: number;
+        spacing: number;
+    };
+    _auto: boolean;
+    _needsFit: boolean;
+    _hover: {
+        index: any;
+        x: number;
+        y: number;
+    } | {
+        index: number;
+        x: number;
+        y: number;
+    };
+    _dt: number;
+    _ly: {
+        W: any;
+        H: any;
+        priceW: number;
+        timeH: number;
+        plotRight: number;
+        plotBottom: number;
+        main: {
+            y0: number;
+            y1: number;
+            h: number;
+        };
+        panes: {
+            entry: any;
+            y0: number;
+            y1: number;
+            h: number;
+        }[];
+    };
+    _cache: {
+        v: number;
+        map: {};
+    };
+    _pal: {
+        overlay: any;
+        volAlpha: number;
+    };
+    _palKey: string;
+    _legendKey: string;
+    _raf: number;
+    _connected: boolean;
+    _theme: string;
+    _type: string;
+    _log: boolean;
+    _precision: any;
+    _label: string;
+    _stats: boolean;
+    _statsKey: string;
+    _profile: boolean;
+    _profileKey: string;
+    _profileRes: {
+        rows: Array<{
+            v: number;
+            up: number;
+            dn: number;
+        }>;
+        maxV: number;
+        total: number;
+        rowH: number;
+        priceMin: number;
+        priceMax: number;
+        pocIndex: number;
+        valIndex: number;
+        vahIndex: number;
+        poc: number;
+        val: number;
+        vah: number;
+    };
+    _annotations: boolean;
+    _annoKey: string;
+    _annoList: {
+        type: string;
+        side: 'high' | 'low';
+        i: number;
+        note: string;
+    }[];
+    _coviewName: any;
+    _coviewCh: BroadcastChannel;
+    _coviewPeer: string;
+    _coviewLast: number;
+    _ghost: {
+        index: number;
+        yFrac: any;
+        at: number;
+    };
+    _ghostTimer: number;
+    _sonify: boolean;
+    _actx: any;
+    _lastToneIdx: number;
+    _playToken: number;
+    _measure: {
+        iA: any;
+        pA: number;
+        iB: any;
+        pB: number;
+        done: boolean;
+    };
+    _measuring: boolean;
+    _ind: {
+        overlays: any[];
+        panes: any[];
+        volume: boolean;
+    };
+    _pointers: Map<any, any>;
+    _pan: {
+        x: number;
+        rightIndex: number;
+        moved: boolean;
+    };
+    _pinch: {
+        dist: number;
+        spacing: number;
+        idxAtMid: number;
+        midX: number;
+    };
+    _loadingMore: boolean;
+    _noMore: boolean;
+    _positions: any[];
+    _alerts: any[];
+    _seq: number;
+    _onResize: () => void;
+    _onPointerDown: (e: any) => void;
+    _onPointerMove: (e: any) => void;
+    _onPointerUp: (e: any) => void;
+    _onPointerLeave: () => void;
+    _onWheel: (e: any) => void;
+    _onDbl: () => void;
+    _onKey: (e: any) => void;
+    tabIndex: number;
+    _ro: any;
+    _posVersion: any;
+    _pendingRange: {
+        from: number;
+        to: number;
+    };
+    _W: any;
+    _H: any;
+    _dpr: any;
+    _lastScale: {
+        min: number;
+        max: number;
+        useLog: boolean;
+        rawMin: number;
+        rawHi: number;
+    };
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: any, _old: any, val: any): void;
+    static _registryMap: any;
+    /** Lazily-built registry, seeded with the built-in indicators. */
+    static _registry(): any;
+    /**
+     * Register a custom indicator.
+     *
+     *   HabChart.registerIndicator('vwap', {
+     *     kind: 'overlay',                    // or 'pane'
+     *     params: { period: 20 },             // defaults; settable via name:period
+     *     compute(bars, params) {             // bars: normalized {time,o,h,l,c,v}
+     *       return smaOfCloses;               // single series…
+     *       // …or { lines: [{name, values}], histogram } for multi-line/panes
+     *     },
+     *     guides: [30, 70],                   // pane only: dashed guide levels
+     *     range: [0, 100],                    // pane only: fixed scale
+     *     fmt: 'price' | 'fixed1',            // legend/axis number format
+     *   });
+     *   chart.indicators = 'vwap:20';
+     */
+    /** @param {import('./core.js').IndicatorDef} def */
+    static registerIndicator(name: any, def: import('./core.js').IndicatorDef): void;
+    /** The custom element class (also exported implicitly for users). */
+    static get elementName(): string;
+    get data(): any[];
+    /**
+     * Replace the dataset.
+     * @param {Array<import('./core.js').Bar>} bars
+     */
+    setData(bars: Array<import('./core.js').Bar>): void;
+    /**
+     * Stream a bar: replaces the last bar when `time` matches, appends when
+     * newer, inserts/backfills when older.
+     * @param {import('./core.js').Bar} bar
+     */
+    update(bar: import('./core.js').Bar): void;
+    clearData(): void;
+    /**
+     * Fetch older history when the view approaches the left edge.
+     * The host app assigns `chart.onloadmore = async (fromTime) => bars`.
+     * Bars strictly older than the current first bar are prepended and the
+     * view stays anchored. Return [] / null to signal "no more data".
+     * @type {null|((fromTime: number) => Promise<Array<import('./core.js').Bar>>|Array<import('./core.js').Bar>)}
+     */
+    onloadmore: null | ((fromTime: number) => Promise<Array<import('./core.js').Bar>> | Array<import('./core.js').Bar>);
+    _maybeLoadMore(iLeft: any): void;
+    /** Reset zoom to the default view (last ~150 bars). */
+    fit(): void;
+    /** Visible time window. @returns {{from:number,to:number}|null} */
+    /** @returns {{from: number, to: number}|null} visible time window (ms) */
+    getVisibleRange(): {
+        from: number;
+        to: number;
+    } | null;
+    /** Set visible time window ({from, to} in ms). */
+    /** @param {{from: number, to: number}} range times in ms */
+    setVisibleRange(range: {
+        from: number;
+        to: number;
+    }): void;
+    /** Current canvas as a PNG data URL. */
+    exportPNG(): any;
+    /**
+     * Serializable snapshot of the chart's configuration and view.
+     * Feed it to setState() (or encodeStateQuery for shareable URLs).
+     */
+    /** @returns {import('./core.js').ChartState} */
+    getState(): import('./core.js').ChartState;
+    /**
+     * Apply a state snapshot (from getState()). If a view range is included
+     * and data is not loaded yet, it is applied after the next setData().
+     * @param {import('./core.js').ChartState} state
+     */
+    setState(state: import('./core.js').ChartState): void;
+    /**
+     * Visualize a position / order.
+     * @param {{id?: string, side?: 'long'|'short', entry: number,
+     *          stop?: number, target?: number, qty?: number}} pos
+     * @returns {string|null} the position id
+     */
+    addPosition(pos: {
+        id?: string;
+        side?: 'long' | 'short';
+        entry: number;
+        stop?: number;
+        target?: number;
+        qty?: number;
+    }): string | null;
+    removePosition(id: any): void;
+    clearPositions(): void;
+    /**
+     * Price alert. Fires `hab:alert` ({id, price, bar}) on an edge crossing
+     * during streaming updates.
+     * @param {{id?: string, price: number, direction?: 'above'|'below'|'cross',
+     *          once?: boolean}} alert
+     * @returns {string|null} the alert id
+     */
+    addAlert(alert: {
+        id?: string;
+        price: number;
+        direction?: 'above' | 'below' | 'cross';
+        once?: boolean;
+    }): string | null;
+    removeAlert(id: any): void;
+    clearAlerts(): void;
+    /** Check alerts against an incoming bar (prev close → new close). */
+    _checkAlerts(prevClose: any, bar: any): void;
+    get theme(): string;
+    set theme(v: string);
+    get type(): string;
+    set type(v: string);
+    get label(): string;
+    set label(v: string);
+    get indicators(): any;
+    set indicators(v: any);
+    static _MAX_SP: number;
+    /**
+     * Lowest allowed px/bar: either 0.35, or whatever fits the entire
+     * dataset on screen — so any history can be zoomed out fully.
+     */
+    _minSpacing(): number;
+    static _timeToMs(t: any): any;
+    static _normBar(b: any): {
+        time: any;
+        open: any;
+        high: any;
+        low: any;
+        close: any;
+        volume: any;
+    };
+    static _indexForTime(d: any, time: any): number;
+    _autoAttr(): boolean;
+    _computeDt(): void;
+    _updateAria(): void;
+    _invalidate(): void;
+    _prec(v: any): any;
+    _palette(): {
+        overlay: any;
+        volAlpha: any;
+    };
+    /**
+     * Bars used for drawing/reading OHLC: raw data, or the Heikin-Ashi
+     * transform for `type="heikin"` (cached per data version).
+     */
+    _renderBars(): any;
+    /** RSI(14) over raw closes, cached per data version (annotation input). */
+    _cachedRSI14(): any;
+    /** Compute (and cache per data version) an indicator entry's series. */
+    _indicatorSeries(entry: any): any;
+    /** Resolve a line color: #hex / rgb() / CSS name / palette key ('rsi', 'up', …) / cycle.
+     *  Untrusted values (URL/attribute-sourced) are validated — never interpolated raw. */
+    _lineColor(entry: any, line: any, pal: any, cycleIdx: any): any;
+    _ensureCanvas(): boolean;
+    _rightMargin(): number;
+    _applyFit(): void;
+    _clampView(): void;
+    _atRight(): boolean;
+    _xFor(i: any): number;
+    _indexForX(x: any): number;
+    _mainScale(i0: any, i1: any, cols: any): {
+        min: number;
+        max: number;
+        useLog: boolean;
+        rawMin: number;
+        rawHi: number;
+    };
+    _priceTicks(scale: any, height: any): any[];
+    /**
+     * Time-axis ticks. `sampleIdx` (optional, ascending indices) restricts
+     * the walk to those bars — used at deep zoom where bars are aggregated
+     * into pixel columns (keeps this O(screen) instead of O(visible bars)).
+     */
+    _timeTicks(i0: any, i1: any, sampleIdx: any): any[];
+    _render(): void;
+    _pill(x: any, y: any, text: any, bg: any, fg: any, align: string, widthOverride: any): void;
+    _updateLegend(): void;
+    /** Position P&L chips (top-right HTML overlay). */
+    _updateHud(): void;
+    _localPoint(e: any): {
+        x: number;
+        y: number;
+    };
+    _pointerDown(e: any): void;
+    _pointerMove(e: any): void;
+    _pointerUp(e: any): void;
+    _yToPrice(y: any): number;
+    _wheel(e: any): void;
+    _keydown(e: any): void;
+    /** Lazily-created shared AudioContext (enable within a user gesture). */
+    _audio(): any;
+    /** Short sine blip; `when` schedules against AudioContext time. */
+    _tone(freq: any, dur?: number, when?: number): void;
+    /** One tone for a bar's close, pitched by its position on the y-scale. */
+    _sonifyBar(i: any): void;
+    /** One tone per crosshair bar change (dedupes y-only moves). */
+    _maybeSonify(idx: any): void;
+    /**
+     * Play the visible range as a pitch sweep (~4s), riding the crosshair —
+     * the audible equivalent of running your eye along the price line.
+     */
+    playRange(): void;
+    _emitCrosshair(hover: any): void;
+    /** Join/leave the co-view channel named by the `co-view` attribute. */
+    _setupCoView(): void;
+    _coviewSend(msg: any): void;
+    _onCoMessage(m: any): void;
+    _emitRange(): void;
+}
+export default HabChart;

package/types/hab-feed.d.ts

@@ -0,0 +1,27 @@
+import './hab-chart.js';
+declare const HTMLElementBase: {
+    new (): {};
+};
+declare class HabFeed extends HTMLElementBase {
+    _gen: number;
+    _closers: any[];
+    _timer: number;
+    _observer: any;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: any, oldVal: any, newVal: any): void;
+    _scheduleRestart(): void;
+    _teardown(): void;
+    _setStatus(status: any, detail: any): void;
+    /** Resolve the target chart (by `for` id, else the first <hab-chart>). */
+    _resolveChart(): Element;
+    _restart(): void;
+    _synthetic(gen: any, chart: any, key: any, tfId: any, limit: any, live: any, status?: string): void;
+    _binance(gen: any, chart: any, sym: any, tfId: any, limit: any, live: any): Promise<void>;
+    _pollBinance(gen: any, chart: any, sym: any, tfId: any): void;
+    _degrade(gen: any, chart: any, sym: any, tfId: any, limit: any, live: any, err: any): void;
+    _rest(gen: any, chart: any, url: any, limit: any, live: any): Promise<void>;
+}
+export default HabFeed;