@zuttora/charts 0.0.0-stage → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nishit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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
+AUTHORS OR COPYRIGHT HOLDERS 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

@@ -1,3 +1,63 @@
-# Temporary Holding Version
+# chartZ (`@zuttora/charts`)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Zuttora's own charting package: candlesticks on an HTML canvas, square corners, no runtime
+dependencies. The full design is in Zuttora's `docs/charting.md` (section 6).
+
+```ts
+import { createChart, zuttoraTheme, INTERVAL_MS, IST_OFFSET_MS } from '@zuttora/charts';
+
+const chart = createChart(container, {   // the container must have a height
+  intervalMs: INTERVAL_MS['5m'],
+  tzOffsetMs: IST_OFFSET_MS,
+  priceDecimals: 2,
+  minMove: 0.05,
+  theme: { ...zuttoraTheme, fontFamily: resolvedFontFamily },
+});
+
+chart.setData(closedCandles, formingCandle, hasMore);   // Candle = { t, o, h, l, c }, t = slot start in epoch ms
+chart.applyTick(price, serverTime);                      // live prices: the last candle moves, slots roll over
+chart.on('needMore', (oldest) => { /* load older candles, then chart.prependData(older, hasMore) */ });
+chart.on('liveChange', (atLive) => { /* show or hide a "Go to live" button */ });
+```
+
+Also: `replaceClosed`, `setOptions`, `setPriceLines`, `setMarkers`, `setIndicators`, `setDrawingTool`, `setDrawings`, `getDrawings`, `updateDrawing`, `deleteSelected`, `clearDrawings`, `setDrawingColor`, `scrollToLive`, `fitAll`, `destroy`.
+
+Drawing tools (`setDrawingTool(tool)`): `hline`, `trend`, `ray`, `rect`, `fib`, `note` and `measure` (a ruler that is never saved). Tap or click to place each point, or press and drag. A finished drawing is picked; drag it to move it, drag a square to move one point, `Delete` removes it, `Escape` backs out. Drawings sit at a time and a price, so they stay in place when the candle size changes.
+The host owns saving: listen to `drawingsChange(list)`, store it, and restore with `setDrawings(list)`. `drawingEdit(drawing)` fires when a note needs its words (`updateDrawing(id, { text })`); `drawProgress` tells a hint line how far along the trader is; `setDrawingColor(color)` colours the next drawing and the picked one.
+
+Indicators (`setIndicators(specs)`, diffed by `id`): `sma`, `ema` and `bollinger` are drawn over the candles; `rsi` and `macd` get their own pane under the price.
+They are calculated from every loaded close, the forming candle included, so they move live.
+
+```js
+chart.setIndicators([
+  { id: 'sma20', type: 'sma', period: 20, color: '#FFD34D' },
+  { id: 'rsi', type: 'rsi', period: 14, color: '#C792EA' },
+]);
+```
+
+Gestures: drag to pan, wheel or pinch to zoom, press and hold (touch) or hover (mouse) for the
+crosshair, drag the price axis to scale it, double-click or double-tap to reset, arrow keys, `+`/`-`,
+`Home`, `End`.
+
+## Status
+
+| | |
+|---|---|
+| Core, rendering, interaction (M3 to M5) | done |
+| Indicators (M8) | done, `0.2.0` |
+| Drawing tools (M9) | done, `0.3.0` |
+| Published to npm | after review (needs the `NPM_TOKEN` secret) |
+
+## Develop
+
+```
+yarn install
+yarn typecheck && yarn lint && yarn test && yarn build && yarn size
+python3 -m http.server   # then open http://localhost:8000/demo/  (after yarn build)
+```
+
+Demo URL options: `?type=candles|line|area|heikinAshi&interval=1m|5m|10m|1h|3h|6h|1D&tick=200` (ms between fake ticks).
+
+Rules: no runtime dependencies, TypeScript that Node can run by stripping types (no `enum`,
+`namespace` or constructor parameter properties), relative imports with the `.ts` extension, no
+rounded corners, no `console` outside `src/core/warn.ts`.

package/dist/chart.d.ts

@@ -0,0 +1,8 @@
+import type { Chart, ChartOptions } from './core/types.ts';
+import type { ChartHost } from './host.ts';
+export type { ChartHost } from './host.ts';
+export interface ChartCore {
+    chart: Chart;
+    host: ChartHost;
+}
+export declare function createChartCore(container: HTMLElement, options: ChartOptions): ChartCore;

package/dist/chart.js

@@ -0,0 +1,238 @@
+import { createDrawApi } from "./drawApi.js";
+import { Emitter } from "./core/emitter.js";
+import { buildDom } from "./dom/root.js";
+import { watchEnvironment } from "./dom/environment.js";
+import { syncLegend } from "./dom/legendSync.js";
+import { createHost } from "./host.js";
+import { createState, resolveOptions } from "./chartState.js";
+import { CLOSE_TWEEN_MS } from "./render/frameBuilder.js";
+import { paintFrame } from "./render/paintFrame.js";
+import { Scheduler } from "./render/scheduler.js";
+const perf = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());
+export function createChartCore(container, options) {
+    const doc = container.ownerDocument;
+    const s = createState(resolveOptions(options));
+    const events = new Emitter();
+    let destroyed = false;
+    let lastFrame = null;
+    const { root, mainCanvas, overlayCanvas, legend } = buildDom(doc, s.options.theme);
+    container.appendChild(root);
+    const applyAria = () => root.setAttribute('aria-label', s.options.ariaLabel);
+    const applyFocusRing = () => {
+        root.style.setProperty('--zc-focus', s.options.theme.accent);
+    };
+    applyAria();
+    applyFocusRing();
+    const updateLegend = () => syncLegend(s, legend);
+    const checkEvents = () => {
+        const live = s.vp.atLive();
+        if (live !== s.lastLive) {
+            s.lastLive = live;
+            events.emit('liveChange', live);
+        }
+        if (s.series.count > 0 && s.moreGate.check(s.vp.leftIndex(), s.series.hasMore)) {
+            events.emit('needMore', s.series.timeAt(0));
+        }
+    };
+    const draw = (flags, now) => {
+        if (destroyed)
+            return false;
+        return paintFrame(s, {
+            mainCanvas,
+            overlayCanvas,
+            dpr: () => env.dpr(),
+            frameBuilt: (f) => {
+                lastFrame = f;
+            },
+            afterDraw: checkEvents,
+        }, flags, now);
+    };
+    const scheduler = new Scheduler(draw);
+    const invalidate = (layer) => scheduler.invalidate(layer);
+    const invalidateAll = () => {
+        invalidate('main');
+        invalidate('overlay');
+    };
+    const resize = () => {
+        const r = container.getBoundingClientRect();
+        s.width = Math.max(0, Math.floor(r.width));
+        s.height = Math.max(0, Math.floor(r.height));
+        invalidateAll();
+    };
+    resize();
+    const env = watchEnvironment(container, doc, {
+        resize,
+        densityChanged: invalidateAll,
+        second: () => {
+            if (s.series.forming)
+                invalidate('overlay');
+        },
+        visible: invalidateAll,
+    });
+    const animNow = perf;
+    const drawApi = createDrawApi({
+        s,
+        root,
+        events,
+        invalidate,
+        lastFrame: () => lastFrame,
+        now: animNow,
+        isDestroyed: () => destroyed,
+    });
+    const chart = {
+        setData(closed, forming, hasMore) {
+            if (destroyed)
+                return;
+            const hadData = s.series.count > 0;
+            const wasLive = !hadData || s.vp.atLive();
+            const edge = Math.round(s.vp.rightIndex);
+            const frac = s.vp.rightIndex - edge;
+            const keepT = hadData && !wasLive ? s.series.timeAt(Math.min(edge, s.series.lastIndex())) : null;
+            s.series.setData(closed, forming, hasMore);
+            s.haBars.rebuild();
+            s.indicators.rebuild(s.series);
+            s.vp.setLastIndex(s.series.lastIndex());
+            s.moreGate.clear();
+            s.closeTween.jump(forming ? forming.c : 0);
+            s.rightAnimating = false;
+            if (keepT !== null) {
+                const i = s.series.indexAtTime(keepT);
+                if (i >= 0 && s.series.timeAt(i) === keepT)
+                    s.vp.setRightIndex(i + frac);
+                else
+                    s.vp.goLive();
+            }
+            else {
+                s.vp.goLive();
+            }
+            s.rangeReady = false;
+            updateLegend();
+            invalidateAll();
+        },
+        prependData(older, hasMore) {
+            if (destroyed)
+                return;
+            const added = s.series.prependData(older, hasMore);
+            if (added > 0) {
+                s.vp.onPrepend(added);
+                s.haBars.rebuild();
+                s.indicators.rebuild(s.series);
+            }
+            s.moreGate.clear();
+            updateLegend();
+            invalidateAll();
+        },
+        replaceClosed(candles) {
+            if (destroyed)
+                return;
+            if (s.series.replaceClosed(candles) > 0) {
+                s.haBars.rebuild();
+                s.indicators.rebuild(s.series);
+                updateLegend();
+                invalidateAll();
+            }
+        },
+        applyTick(price, time) {
+            if (destroyed)
+                return;
+            const r = s.series.applyTick(price, time, s.options.intervalMs, s.options.tzOffsetMs);
+            if (r.kind === 'ignored')
+                return;
+            s.indicators.onTick(s.series, r);
+            const t = animNow();
+            if (r.kind === 'updated') {
+                s.closeTween.set(price, t, s.options.reducedMotion ? 0 : CLOSE_TWEEN_MS);
+            }
+            else {
+                if (r.kind === 'closed' && r.shifted > 0)
+                    s.vp.onShift(r.shifted);
+                s.vp.onAppend(s.series.lastIndex());
+                s.closeTween.jump(price);
+                s.haBars.rebuild();
+            }
+            s.haBars.refreshForming();
+            if (!s.options.reducedMotion && (s.options.type === 'line' || s.options.type === 'area')) {
+                s.pulses.push(t);
+                if (s.pulses.length > 8)
+                    s.pulses.shift();
+            }
+            if (r.kind === 'closed')
+                events.emit('candleClosed', r.closed);
+            if (!s.crosshair)
+                updateLegend();
+            invalidateAll();
+        },
+        setOptions(patch) {
+            if (destroyed)
+                return;
+            const next = resolveOptions({ ...s.options, ...patch, labels: { ...s.options.labels, ...patch.labels } });
+            s.options = next;
+            s.haBars.rebuild();
+            legend.applyTheme(next.theme);
+            applyAria();
+            applyFocusRing();
+            s.textWidths.clear();
+            s.rangeReady = false;
+            updateLegend();
+            invalidateAll();
+        },
+        setPriceLines(lines) {
+            if (destroyed)
+                return;
+            s.lines = lines.slice();
+            invalidate('main');
+        },
+        setMarkers(markers) {
+            if (destroyed)
+                return;
+            s.markers = markers.slice();
+            updateLegend();
+            invalidate('main');
+        },
+        setIndicators(specs) {
+            if (destroyed)
+                return;
+            s.indicators.setSpecs(specs, s.series);
+            s.rangeReady = false;
+            updateLegend();
+            invalidateAll();
+        },
+        ...drawApi.methods,
+        scrollToLive() {
+            host.scrollToLive();
+        },
+        fitAll() {
+            if (destroyed)
+                return;
+            s.vp.fitAll();
+            s.rightAnimating = false;
+            invalidateAll();
+        },
+        on(event, listener) {
+            return events.on(event, listener);
+        },
+        destroy() {
+            if (destroyed)
+                return;
+            destroyed = true;
+            scheduler.stop();
+            env.dispose();
+            events.clear();
+            host.dispose();
+            root.remove();
+        },
+    };
+    const host = createHost({
+        root,
+        state: s,
+        draw: drawApi.controller,
+        events,
+        invalidate,
+        invalidateAll,
+        updateLegend,
+        isDestroyed: () => destroyed,
+        lastFrame: () => lastFrame,
+        now: animNow,
+    });
+    return { chart, host };
+}

package/dist/chartState.d.ts

@@ -0,0 +1,47 @@
+import { CandleSeries } from './core/series.ts';
+import { PriceScale } from './core/priceScale.ts';
+import type { Drawing } from './core/drawings.ts';
+import { IndicatorSet } from './core/indicatorSet.ts';
+import type { DrawState } from './draw/controller.ts';
+import { MoreGate, Viewport } from './core/viewport.ts';
+import type { ChartLabels, ChartOptions, Marker, PriceLine } from './core/types.ts';
+import { HeikinBars, SeriesBars } from './render/bars.ts';
+import type { CrosshairInput } from './render/drawCrosshair.ts';
+import { Tween } from './render/tween.ts';
+export declare const DEFAULT_LABELS: ChartLabels;
+export interface ResolvedOptions extends Required<Omit<ChartOptions, 'labels' | 'ariaLabel' | 'now' | 'reducedMotion'>> {
+    labels: ChartLabels;
+    ariaLabel: string;
+    now: () => number;
+    reducedMotion: boolean;
+}
+export declare function resolveOptions(o: ChartOptions): ResolvedOptions;
+export interface ChartState {
+    options: ResolvedOptions;
+    series: CandleSeries;
+    vp: Viewport;
+    scale: PriceScale;
+    plainBars: SeriesBars;
+    haBars: HeikinBars;
+    moreGate: MoreGate;
+    lines: readonly PriceLine[];
+    markers: readonly Marker[];
+    indicators: IndicatorSet;
+    drawings: Drawing[];
+    draw: DrawState;
+    rangeMin: Tween;
+    rangeMax: Tween;
+    rangeReady: boolean;
+    closeTween: Tween;
+    rightTween: Tween;
+    rightAnimating: boolean;
+    axisWidth: number;
+    textWidths: Map<string, number>;
+    width: number;
+    height: number;
+    crosshair: CrosshairInput | null;
+    pulses: number[];
+    lastLive: boolean;
+    lastCrosshairTime: number | null;
+}
+export declare function createState(options: ResolvedOptions): ChartState;

package/dist/chartState.js

@@ -0,0 +1,64 @@
+import { CandleSeries } from "./core/series.js";
+import { PriceScale } from "./core/priceScale.js";
+import { IndicatorSet } from "./core/indicatorSet.js";
+import { createDrawState } from "./draw/controller.js";
+import { MoreGate, Viewport } from "./core/viewport.js";
+import { HeikinBars, SeriesBars } from "./render/bars.js";
+import { Tween } from "./render/tween.js";
+export const DEFAULT_LABELS = {
+    open: 'O',
+    high: 'H',
+    low: 'L',
+    close: 'C',
+    change: 'Change',
+    noData: 'No data yet',
+    heikinAshi: 'Heikin-Ashi (smoothed)',
+};
+export function resolveOptions(o) {
+    return {
+        intervalMs: o.intervalMs,
+        tzOffsetMs: o.tzOffsetMs,
+        priceDecimals: o.priceDecimals,
+        minMove: o.minMove ?? 10 ** -o.priceDecimals,
+        type: o.type ?? 'candles',
+        candleStyle: o.candleStyle ?? 'hollowUp',
+        theme: o.theme,
+        labels: { ...DEFAULT_LABELS, ...o.labels },
+        locale: o.locale ?? 'en-IN',
+        now: o.now ?? (() => Date.now()),
+        reducedMotion: o.reducedMotion ??
+            (typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches),
+        ariaLabel: o.ariaLabel ?? 'Price chart',
+    };
+}
+export function createState(options) {
+    const series = new CandleSeries();
+    return {
+        options,
+        series,
+        vp: new Viewport(),
+        scale: new PriceScale(),
+        plainBars: new SeriesBars(series),
+        haBars: new HeikinBars(series),
+        moreGate: new MoreGate(),
+        lines: [],
+        markers: [],
+        indicators: new IndicatorSet(),
+        drawings: [],
+        draw: createDrawState(options.theme.accent),
+        rangeMin: new Tween(0),
+        rangeMax: new Tween(1),
+        rangeReady: false,
+        closeTween: new Tween(0),
+        rightTween: new Tween(0),
+        rightAnimating: false,
+        axisWidth: 0,
+        textWidths: new Map(),
+        width: 0,
+        height: 0,
+        crosshair: null,
+        pulses: [],
+        lastLive: true,
+        lastCrosshairTime: null,
+    };
+}

package/dist/core/drawings.d.ts

@@ -0,0 +1,21 @@
+import type { Time } from './types.ts';
+export type DrawingTool = 'hline' | 'trend' | 'ray' | 'rect' | 'fib' | 'note' | 'measure';
+export type DrawingKind = Exclude<DrawingTool, 'measure'>;
+export interface Point {
+    t: Time;
+    price: number;
+}
+export interface Drawing {
+    id: string;
+    type: DrawingKind;
+    points: Point[];
+    color: string;
+    text?: string;
+}
+export declare const MAX_DRAWINGS = 100;
+export declare const MAX_NOTE_LENGTH = 60;
+export declare const FIB_LEVELS: readonly number[];
+export declare function pointsNeeded(tool: DrawingTool): number;
+export declare function isKind(tool: string): tool is DrawingKind;
+export declare function newDrawingId(): string;
+export declare function sanitizeDrawings(list: readonly unknown[]): Drawing[];

package/dist/core/drawings.js

@@ -0,0 +1,46 @@
+export const MAX_DRAWINGS = 100;
+export const MAX_NOTE_LENGTH = 60;
+export const FIB_LEVELS = [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1];
+const KINDS = ['hline', 'trend', 'ray', 'rect', 'fib', 'note'];
+export function pointsNeeded(tool) {
+    return tool === 'hline' || tool === 'note' ? 1 : 2;
+}
+export function isKind(tool) {
+    return KINDS.includes(tool);
+}
+let counter = 0;
+export function newDrawingId() {
+    counter += 1;
+    return `d${Date.now().toString(36)}${counter.toString(36)}`;
+}
+const finite = (n) => typeof n === 'number' && Number.isFinite(n);
+export function sanitizeDrawings(list) {
+    const out = [];
+    const ids = new Set();
+    for (const raw of list) {
+        if (out.length >= MAX_DRAWINGS)
+            break;
+        if (typeof raw !== 'object' || raw === null)
+            continue;
+        const d = raw;
+        if (typeof d.id !== 'string' || ids.has(d.id) || typeof d.type !== 'string' || !isKind(d.type))
+            continue;
+        if (typeof d.color !== 'string' || !Array.isArray(d.points))
+            continue;
+        const need = pointsNeeded(d.type);
+        const points = [];
+        for (const p of d.points.slice(0, need)) {
+            const q = p;
+            if (q && finite(q.t) && finite(q.price))
+                points.push({ t: q.t, price: q.price });
+        }
+        if (points.length !== need)
+            continue;
+        const drawing = { id: d.id, type: d.type, points, color: d.color };
+        if (d.type === 'note')
+            drawing.text = typeof d.text === 'string' ? d.text.slice(0, MAX_NOTE_LENGTH) : '';
+        ids.add(d.id);
+        out.push(drawing);
+    }
+    return out;
+}

package/dist/core/emitter.d.ts

@@ -0,0 +1,8 @@
+export declare class Emitter<Events extends {
+    [K in keyof Events]: (...args: never[]) => void;
+}> {
+    private map;
+    on<E extends keyof Events>(event: E, listener: Events[E]): () => void;
+    emit<E extends keyof Events>(event: E, ...args: Parameters<Events[E]>): void;
+    clear(): void;
+}

package/dist/core/emitter.js

@@ -0,0 +1,26 @@
+export class Emitter {
+    constructor() {
+        this.map = new Map();
+    }
+    on(event, listener) {
+        let set = this.map.get(event);
+        if (!set) {
+            set = new Set();
+            this.map.set(event, set);
+        }
+        set.add(listener);
+        return () => {
+            set.delete(listener);
+        };
+    }
+    emit(event, ...args) {
+        const set = this.map.get(event);
+        if (!set)
+            return;
+        for (const fn of [...set])
+            fn(...args);
+    }
+    clear() {
+        this.map.clear();
+    }
+}

package/dist/core/format.d.ts

@@ -0,0 +1,9 @@
+export declare function priceFormatter(decimals: number, locale?: string): (value: number) => string;
+export declare function formatCountdown(msLeft: number): string;
+export interface ChangeParts {
+    direction: 1 | -1 | 0;
+    arrow: '▲' | '▼' | '';
+    amount: string;
+    percent: string;
+}
+export declare function changeParts(o: number, c: number, decimals: number, locale?: string): ChangeParts;

package/dist/core/format.js

@@ -0,0 +1,35 @@
+const formatters = new Map();
+export function priceFormatter(decimals, locale = 'en-IN') {
+    const key = `${locale}|${decimals}`;
+    let f = formatters.get(key);
+    if (!f) {
+        f = new Intl.NumberFormat(locale, { minimumFractionDigits: decimals, maximumFractionDigits: decimals });
+        formatters.set(key, f);
+    }
+    const fmt = f;
+    return (value) => fmt.format(value);
+}
+export function formatCountdown(msLeft) {
+    const total = Math.max(0, Math.ceil(msLeft / 1000));
+    const h = Math.floor(total / 3600);
+    const m = Math.floor((total % 3600) / 60);
+    const s = total % 60;
+    const ss = s < 10 ? `0${s}` : String(s);
+    if (h > 0)
+        return `${h}:${m < 10 ? '0' : ''}${m}:${ss}`;
+    return `${m}:${ss}`;
+}
+export function changeParts(o, c, decimals, locale = 'en-IN') {
+    const fmt = priceFormatter(decimals, locale);
+    const pctFmt = priceFormatter(2, locale);
+    const diff = c - o;
+    const direction = diff > 0 ? 1 : diff < 0 ? -1 : 0;
+    const pct = o !== 0 ? (diff / o) * 100 : 0;
+    const sign = direction > 0 ? '+' : direction < 0 ? '−' : '';
+    return {
+        direction,
+        arrow: direction > 0 ? '▲' : direction < 0 ? '▼' : '',
+        amount: `${sign}${fmt(Math.abs(diff))}`,
+        percent: `${sign}${pctFmt(Math.abs(pct))}%`,
+    };
+}

package/dist/core/heikinAshi.d.ts

@@ -0,0 +1,2 @@
+import type { Candle } from './types.ts';
+export declare function heikinAshi(candles: readonly Candle[]): Candle[];

package/dist/core/heikinAshi.js

@@ -0,0 +1,14 @@
+export function heikinAshi(candles) {
+    const out = [];
+    let prevO = 0;
+    let prevC = 0;
+    for (let i = 0; i < candles.length; i++) {
+        const k = candles[i];
+        const c = (k.o + k.h + k.l + k.c) / 4;
+        const o = i === 0 ? (k.o + k.c) / 2 : (prevO + prevC) / 2;
+        out.push({ t: k.t, o, h: Math.max(k.h, o, c), l: Math.min(k.l, o, c), c });
+        prevO = o;
+        prevC = c;
+    }
+    return out;
+}

package/dist/core/indicatorSet.d.ts

@@ -0,0 +1,20 @@
+import type { CandleSeries, TickResult } from './series.ts';
+import type { Calc } from './indicators.ts';
+import type { IndicatorSpec } from './types.ts';
+export declare const MAX_INDICATORS = 8;
+export interface IndicatorEntry {
+    spec: IndicatorSpec;
+    calc: Calc;
+    key: string;
+}
+export declare class IndicatorSet {
+    entries: IndicatorEntry[];
+    private closes;
+    get subCount(): number;
+    main(): IndicatorEntry[];
+    subs(): IndicatorEntry[];
+    setSpecs(specs: readonly IndicatorSpec[], series: CandleSeries): void;
+    rebuild(series: CandleSeries): void;
+    onTick(series: CandleSeries, result: TickResult): void;
+    private loadCloses;
+}