@zuttora/charts 0.0.0-stage → 0.3.0

package/dist/core/indicatorSet.js

@@ -0,0 +1,66 @@
+import { isSubPane, makeCalc } from "./indicators.js";
+export const MAX_INDICATORS = 8;
+const keyOf = (spec) => JSON.stringify({ ...spec, color: undefined, signalColor: undefined });
+export class IndicatorSet {
+    constructor() {
+        this.entries = [];
+        this.closes = [];
+    }
+    get subCount() {
+        let n = 0;
+        for (const e of this.entries)
+            if (isSubPane(e.spec))
+                n++;
+        return n;
+    }
+    main() {
+        return this.entries.filter((e) => !isSubPane(e.spec));
+    }
+    subs() {
+        return this.entries.filter((e) => isSubPane(e.spec));
+    }
+    setSpecs(specs, series) {
+        const old = new Map(this.entries.map((e) => [e.spec.id, e]));
+        const next = [];
+        const seen = new Set();
+        for (const spec of specs) {
+            if (seen.has(spec.id) || next.length >= MAX_INDICATORS)
+                continue;
+            seen.add(spec.id);
+            const key = keyOf(spec);
+            const kept = old.get(spec.id);
+            next.push(kept && kept.key === key ? { ...kept, spec } : { spec, key, calc: makeCalc(spec) });
+        }
+        const fresh = next.filter((e) => !this.entries.some((o) => o.calc === e.calc));
+        this.entries = next;
+        if (fresh.length > 0) {
+            this.loadCloses(series);
+            for (const e of fresh)
+                e.calc.computeFrom(this.closes, 0);
+        }
+    }
+    rebuild(series) {
+        if (this.entries.length === 0)
+            return;
+        this.loadCloses(series);
+        for (const e of this.entries)
+            e.calc.computeFrom(this.closes, 0);
+    }
+    onTick(series, result) {
+        if (this.entries.length === 0 || result.kind === 'ignored')
+            return;
+        const n = series.count;
+        if ((result.kind === 'closed' && result.shifted > 0) || this.closes.length < n - 1 || this.closes.length > n) {
+            this.rebuild(series);
+            return;
+        }
+        this.closes[n - 1] = series.closeAt(n - 1);
+        for (const e of this.entries)
+            e.calc.computeFrom(this.closes, n - 1);
+    }
+    loadCloses(series) {
+        this.closes = [];
+        for (let i = 0; i < series.count; i++)
+            this.closes.push(series.closeAt(i));
+    }
+}

package/dist/core/indicators.d.ts

@@ -0,0 +1,53 @@
+import type { IndicatorSpec } from './types.ts';
+export type Values = (number | null)[];
+export interface Calc {
+    computeFrom(closes: readonly number[], from: number): void;
+    lines: Record<string, Values>;
+}
+export declare class Sma implements Calc {
+    readonly values: Values;
+    readonly lines: Record<string, Values>;
+    private period;
+    constructor(period: number);
+    computeFrom(closes: readonly number[], from: number): void;
+}
+export declare class Ema implements Calc {
+    readonly values: Values;
+    readonly lines: Record<string, Values>;
+    private period;
+    private k;
+    constructor(period: number);
+    computeFrom(input: readonly (number | null)[], from: number): void;
+}
+export declare class Bollinger implements Calc {
+    readonly mid: Values;
+    readonly upper: Values;
+    readonly lower: Values;
+    readonly lines: Record<string, Values>;
+    private period;
+    private width;
+    constructor(period: number, stdDev: number);
+    computeFrom(closes: readonly number[], from: number): void;
+}
+export declare class Rsi implements Calc {
+    readonly values: Values;
+    readonly lines: Record<string, Values>;
+    private gain;
+    private loss;
+    private period;
+    constructor(period: number);
+    computeFrom(closes: readonly number[], from: number): void;
+}
+export declare class Macd implements Calc {
+    readonly macd: Values;
+    readonly hist: Values;
+    readonly lines: Record<string, Values>;
+    private fast;
+    private slow;
+    private signal;
+    constructor(fast: number, slow: number, signal: number);
+    computeFrom(closes: readonly number[], from: number): void;
+}
+export declare function makeCalc(spec: IndicatorSpec): Calc;
+export declare function isSubPane(spec: IndicatorSpec): boolean;
+export declare function indicatorTitle(spec: IndicatorSpec): string;

package/dist/core/indicators.js

@@ -0,0 +1,187 @@
+function cut(values, n) {
+    if (values.length > n)
+        values.length = n;
+}
+function whole(n) {
+    return Math.max(1, Math.floor(Number.isFinite(n) ? n : 1));
+}
+function windowMean(x, end, period) {
+    let sum = 0;
+    for (let j = end - period + 1; j <= end; j++)
+        sum += x[j];
+    return sum / period;
+}
+function firstValue(x) {
+    for (let i = 0; i < x.length; i++)
+        if (x[i] !== null)
+            return i;
+    return -1;
+}
+export class Sma {
+    constructor(period) {
+        this.values = [];
+        this.lines = { main: this.values };
+        this.period = whole(period);
+    }
+    computeFrom(closes, from) {
+        cut(this.values, from);
+        for (let i = this.values.length; i < closes.length; i++) {
+            this.values.push(i < this.period - 1 ? null : windowMean(closes, i, this.period));
+        }
+    }
+}
+export class Ema {
+    constructor(period) {
+        this.values = [];
+        this.lines = { main: this.values };
+        this.period = whole(period);
+        this.k = 2 / (this.period + 1);
+    }
+    computeFrom(input, from) {
+        cut(this.values, from);
+        const start = firstValue(input);
+        for (let i = this.values.length; i < input.length; i++) {
+            if (start < 0 || i < start + this.period - 1)
+                this.values.push(null);
+            else if (i === start + this.period - 1)
+                this.values.push(windowMean(input, i, this.period));
+            else {
+                const prev = this.values[i - 1];
+                this.values.push(prev + this.k * (input[i] - prev));
+            }
+        }
+    }
+}
+export class Bollinger {
+    constructor(period, stdDev) {
+        this.mid = [];
+        this.upper = [];
+        this.lower = [];
+        this.lines = { mid: this.mid, upper: this.upper, lower: this.lower };
+        this.period = whole(period);
+        this.width = Number.isFinite(stdDev) ? stdDev : 2;
+    }
+    computeFrom(closes, from) {
+        for (const v of [this.mid, this.upper, this.lower])
+            cut(v, from);
+        for (let i = this.mid.length; i < closes.length; i++) {
+            if (i < this.period - 1) {
+                this.mid.push(null);
+                this.upper.push(null);
+                this.lower.push(null);
+                continue;
+            }
+            const mean = windowMean(closes, i, this.period);
+            let sq = 0;
+            for (let j = i - this.period + 1; j <= i; j++)
+                sq += (closes[j] - mean) ** 2;
+            const band = this.width * Math.sqrt(sq / this.period);
+            this.mid.push(mean);
+            this.upper.push(mean + band);
+            this.lower.push(mean - band);
+        }
+    }
+}
+export class Rsi {
+    constructor(period) {
+        this.values = [];
+        this.lines = { rsi: this.values };
+        this.gain = [];
+        this.loss = [];
+        this.period = whole(period);
+    }
+    computeFrom(closes, from) {
+        for (const v of [this.values, this.gain, this.loss])
+            cut(v, from);
+        const p = this.period;
+        for (let i = this.values.length; i < closes.length; i++) {
+            if (i < p) {
+                this.values.push(null);
+                this.gain.push(null);
+                this.loss.push(null);
+                continue;
+            }
+            let g;
+            let l;
+            if (i === p) {
+                g = 0;
+                l = 0;
+                for (let j = 1; j <= p; j++) {
+                    const d = closes[j] - closes[j - 1];
+                    if (d > 0)
+                        g += d;
+                    else
+                        l -= d;
+                }
+                g /= p;
+                l /= p;
+            }
+            else {
+                const d = closes[i] - closes[i - 1];
+                g = (this.gain[i - 1] * (p - 1) + (d > 0 ? d : 0)) / p;
+                l = (this.loss[i - 1] * (p - 1) + (d < 0 ? -d : 0)) / p;
+            }
+            this.gain.push(g);
+            this.loss.push(l);
+            this.values.push(l === 0 ? (g === 0 ? 50 : 100) : 100 - 100 / (1 + g / l));
+        }
+    }
+}
+export class Macd {
+    constructor(fast, slow, signal) {
+        this.macd = [];
+        this.hist = [];
+        this.fast = new Ema(fast);
+        this.slow = new Ema(slow);
+        this.signal = new Ema(signal);
+        this.lines = { macd: this.macd, signal: this.signal.values, hist: this.hist };
+    }
+    computeFrom(closes, from) {
+        this.fast.computeFrom(closes, from);
+        this.slow.computeFrom(closes, from);
+        cut(this.macd, from);
+        for (let i = this.macd.length; i < closes.length; i++) {
+            const f = this.fast.values[i];
+            const s = this.slow.values[i];
+            this.macd.push(f !== null && f !== undefined && s !== null && s !== undefined ? f - s : null);
+        }
+        this.signal.computeFrom(this.macd, from);
+        cut(this.hist, from);
+        for (let i = this.hist.length; i < closes.length; i++) {
+            const m = this.macd[i];
+            const g = this.signal.values[i];
+            this.hist.push(m !== null && m !== undefined && g !== null && g !== undefined ? m - g : null);
+        }
+    }
+}
+export function makeCalc(spec) {
+    switch (spec.type) {
+        case 'sma':
+            return new Sma(spec.period);
+        case 'ema':
+            return new Ema(spec.period);
+        case 'bollinger':
+            return new Bollinger(spec.period, spec.stdDev);
+        case 'rsi':
+            return new Rsi(spec.period);
+        case 'macd':
+            return new Macd(spec.fast, spec.slow, spec.signal);
+    }
+}
+export function isSubPane(spec) {
+    return spec.type === 'rsi' || spec.type === 'macd';
+}
+export function indicatorTitle(spec) {
+    switch (spec.type) {
+        case 'sma':
+            return `SMA ${spec.period}`;
+        case 'ema':
+            return `EMA ${spec.period}`;
+        case 'bollinger':
+            return `BB ${spec.period} ${spec.stdDev}`;
+        case 'rsi':
+            return `RSI ${spec.period}`;
+        case 'macd':
+            return `MACD ${spec.fast} ${spec.slow} ${spec.signal}`;
+    }
+}

package/dist/core/priceScale.d.ts

@@ -0,0 +1,22 @@
+import type { PriceLine } from './types.ts';
+export declare function niceStep(raw: number, minMove: number): number;
+export interface PriceRange {
+    min: number;
+    max: number;
+}
+export declare function autoRange(bars: PriceRange, extraValues: readonly number[], lines: readonly PriceLine[], minMove: number): PriceRange;
+export declare function pinSide(price: number, range: PriceRange): 'above' | 'below' | null;
+export declare function axisTicks(range: PriceRange, paneHeight: number, minMove: number): number[];
+export declare class PriceScale {
+    top: number;
+    height: number;
+    min: number;
+    max: number;
+    manual: boolean;
+    setPane(top: number, height: number): void;
+    setRange(range: PriceRange): void;
+    y(price: number): number;
+    priceAt(y: number): number;
+    scaleBy(dyPx: number): void;
+    resetAuto(): void;
+}

package/dist/core/priceScale.js

@@ -0,0 +1,92 @@
+export function niceStep(raw, minMove) {
+    const exp = Math.floor(Math.log10(raw));
+    const base = 10 ** exp;
+    const m = raw / base;
+    const nice = m <= 1 ? 1 : m <= 2 ? 2 : m <= 2.5 ? 2.5 : m <= 5 ? 5 : 10;
+    return Math.max(nice * base, minMove);
+}
+export function autoRange(bars, extraValues, lines, minMove) {
+    let min = bars.min;
+    let max = bars.max;
+    for (const v of extraValues) {
+        if (Number.isFinite(v)) {
+            if (v < min)
+                min = v;
+            if (v > max)
+                max = v;
+        }
+    }
+    const span = max - min;
+    const lo = min - 0.5 * span;
+    const hi = max + 0.5 * span;
+    for (const line of lines) {
+        if (line.price >= lo && line.price <= hi) {
+            if (line.price < min)
+                min = line.price;
+            if (line.price > max)
+                max = line.price;
+        }
+    }
+    if (max === min) {
+        const pad = Math.max(Math.abs(max) * 0.001, 10 * minMove);
+        return { min: min - pad, max: max + pad };
+    }
+    const pad = (max - min) * 0.08;
+    return { min: min - pad, max: max + pad };
+}
+export function pinSide(price, range) {
+    if (price > range.max)
+        return 'above';
+    if (price < range.min)
+        return 'below';
+    return null;
+}
+export function axisTicks(range, paneHeight, minMove) {
+    const target = Math.max(2, Math.floor(paneHeight / 40));
+    const span = range.max - range.min;
+    if (!(span > 0))
+        return [];
+    const step = niceStep(span / target, minMove);
+    const out = [];
+    const first = Math.ceil(range.min / step - 1e-9);
+    for (let k = first; k * step <= range.max + step * 1e-9; k++) {
+        out.push(Math.round(k * step * 1e8) / 1e8);
+        if (out.length > 200)
+            break;
+    }
+    return out;
+}
+export class PriceScale {
+    constructor() {
+        this.top = 0;
+        this.height = 1;
+        this.min = 0;
+        this.max = 1;
+        this.manual = false;
+    }
+    setPane(top, height) {
+        this.top = top;
+        this.height = Math.max(1, height);
+    }
+    setRange(range) {
+        this.min = range.min;
+        this.max = range.max;
+    }
+    y(price) {
+        return this.top + ((this.max - price) / (this.max - this.min)) * this.height;
+    }
+    priceAt(y) {
+        return this.max - ((y - this.top) / this.height) * (this.max - this.min);
+    }
+    scaleBy(dyPx) {
+        const factor = Math.exp(dyPx * 0.005);
+        const centre = (this.max + this.min) / 2;
+        const half = ((this.max - this.min) / 2) * factor;
+        this.min = centre - half;
+        this.max = centre + half;
+        this.manual = true;
+    }
+    resetAuto() {
+        this.manual = false;
+    }
+}

package/dist/core/series.d.ts

@@ -0,0 +1,41 @@
+import type { Candle } from './types.ts';
+export declare const MAX_CLOSED = 5000;
+export type TickResult = {
+    kind: 'ignored';
+} | {
+    kind: 'updated';
+} | {
+    kind: 'started';
+} | {
+    kind: 'closed';
+    closed: Candle;
+    shifted: number;
+};
+export declare class CandleSeries {
+    t: number[];
+    o: number[];
+    h: number[];
+    l: number[];
+    c: number[];
+    forming: Candle | null;
+    hasMore: boolean;
+    get closedCount(): number;
+    get count(): number;
+    lastIndex(): number;
+    candleAt(i: number): Candle;
+    timeAt(i: number): number;
+    closeAt(i: number): number;
+    toArray(): Candle[];
+    setData(closed: readonly Candle[], forming: Candle | null, hasMore: boolean): void;
+    prependData(older: readonly Candle[], hasMore: boolean): number;
+    replaceClosed(candles: readonly Candle[]): number;
+    applyTick(price: number, time: number, intervalMs: number, offsetMs: number): TickResult;
+    visibleExtremes(from: number, to: number): {
+        min: number;
+        max: number;
+    } | null;
+    indexAtTime(time: number): number;
+    private closedIndexOf;
+    private push;
+    private dropOldest;
+}

package/dist/core/series.js

@@ -0,0 +1,221 @@
+import { bucketStart } from "./time.js";
+import { warn } from "./warn.js";
+export const MAX_CLOSED = 5000;
+function isValid(k) {
+    return (Number.isFinite(k.t) &&
+        Number.isFinite(k.o) &&
+        Number.isFinite(k.h) &&
+        Number.isFinite(k.l) &&
+        Number.isFinite(k.c) &&
+        k.l <= Math.min(k.o, k.c) &&
+        k.h >= Math.max(k.o, k.c));
+}
+export class CandleSeries {
+    constructor() {
+        this.t = [];
+        this.o = [];
+        this.h = [];
+        this.l = [];
+        this.c = [];
+        this.forming = null;
+        this.hasMore = false;
+    }
+    get closedCount() {
+        return this.t.length;
+    }
+    get count() {
+        return this.t.length + (this.forming ? 1 : 0);
+    }
+    lastIndex() {
+        return this.count - 1;
+    }
+    candleAt(i) {
+        if (i === this.t.length && this.forming)
+            return { ...this.forming };
+        return { t: this.t[i], o: this.o[i], h: this.h[i], l: this.l[i], c: this.c[i] };
+    }
+    timeAt(i) {
+        return i === this.t.length && this.forming ? this.forming.t : this.t[i];
+    }
+    closeAt(i) {
+        return i === this.t.length && this.forming ? this.forming.c : this.c[i];
+    }
+    toArray() {
+        const out = [];
+        for (let i = 0; i < this.count; i++)
+            out.push(this.candleAt(i));
+        return out;
+    }
+    setData(closed, forming, hasMore) {
+        this.t = [];
+        this.o = [];
+        this.h = [];
+        this.l = [];
+        this.c = [];
+        let dropped = 0;
+        let prevT = -Infinity;
+        for (const k of closed) {
+            if (!isValid(k) || k.t <= prevT) {
+                dropped++;
+                continue;
+            }
+            this.push(k);
+            prevT = k.t;
+        }
+        if (forming && (!isValid(forming) || forming.t <= prevT)) {
+            dropped++;
+            forming = null;
+        }
+        this.forming = forming ? { t: forming.t, o: forming.o, h: forming.h, l: forming.l, c: forming.c } : null;
+        this.hasMore = hasMore;
+        if (this.t.length > MAX_CLOSED) {
+            this.dropOldest(this.t.length - MAX_CLOSED);
+            this.hasMore = false;
+        }
+        if (dropped > 0)
+            warn(`dropped ${dropped} invalid candle(s)`);
+    }
+    prependData(older, hasMore) {
+        const oldest = this.count > 0 ? this.timeAt(0) : Infinity;
+        const keep = [];
+        let dropped = 0;
+        let prevT = -Infinity;
+        for (const k of older) {
+            if (!isValid(k) || k.t >= oldest || k.t <= prevT) {
+                dropped++;
+                continue;
+            }
+            keep.push(k);
+            prevT = k.t;
+        }
+        if (dropped > 0)
+            warn(`dropped ${dropped} invalid older candle(s)`);
+        this.hasMore = hasMore;
+        let room = MAX_CLOSED - this.t.length;
+        if (room < 0)
+            room = 0;
+        let added = keep;
+        if (added.length > room) {
+            added = added.slice(added.length - room);
+            this.hasMore = false;
+        }
+        if (added.length === 0)
+            return 0;
+        this.t = added.map((k) => k.t).concat(this.t);
+        this.o = added.map((k) => k.o).concat(this.o);
+        this.h = added.map((k) => k.h).concat(this.h);
+        this.l = added.map((k) => k.l).concat(this.l);
+        this.c = added.map((k) => k.c).concat(this.c);
+        return added.length;
+    }
+    replaceClosed(candles) {
+        let changed = 0;
+        for (const k of candles) {
+            if (!isValid(k))
+                continue;
+            const i = this.closedIndexOf(k.t);
+            if (i < 0)
+                continue;
+            this.o[i] = k.o;
+            this.h[i] = k.h;
+            this.l[i] = k.l;
+            this.c[i] = k.c;
+            changed++;
+        }
+        return changed;
+    }
+    applyTick(price, time, intervalMs, offsetMs) {
+        if (!Number.isFinite(price) || price <= 0)
+            return { kind: 'ignored' };
+        const b = bucketStart(time, intervalMs, offsetMs);
+        const f = this.forming;
+        if (f === null) {
+            const lastClosed = this.t.length > 0 ? this.t[this.t.length - 1] : -Infinity;
+            if (b <= lastClosed)
+                return { kind: 'ignored' };
+            this.forming = { t: b, o: price, h: price, l: price, c: price };
+            return { kind: 'started' };
+        }
+        if (b > f.t) {
+            const closed = { t: f.t, o: f.o, h: f.h, l: f.l, c: f.c };
+            this.push(closed);
+            this.forming = { t: b, o: price, h: price, l: price, c: price };
+            const over = this.t.length - MAX_CLOSED;
+            const shifted = over > 0 ? this.dropOldest(over) : 0;
+            if (shifted > 0)
+                this.hasMore = false;
+            return { kind: 'closed', closed, shifted };
+        }
+        if (b === f.t) {
+            if (price > f.h)
+                f.h = price;
+            if (price < f.l)
+                f.l = price;
+            f.c = price;
+            return { kind: 'updated' };
+        }
+        return { kind: 'ignored' };
+    }
+    visibleExtremes(from, to) {
+        const a = Math.max(0, Math.floor(from));
+        const z = Math.min(this.lastIndex(), Math.ceil(to));
+        if (a > z)
+            return null;
+        let min = Infinity;
+        let max = -Infinity;
+        const n = this.t.length;
+        for (let i = a; i <= z; i++) {
+            const lo = i === n && this.forming ? this.forming.l : this.l[i];
+            const hi = i === n && this.forming ? this.forming.h : this.h[i];
+            if (lo < min)
+                min = lo;
+            if (hi > max)
+                max = hi;
+        }
+        return { min, max };
+    }
+    indexAtTime(time) {
+        if (this.count === 0 || time < this.timeAt(0))
+            return -1;
+        let lo = 0;
+        let hi = this.count - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (this.timeAt(mid) <= time)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return lo;
+    }
+    closedIndexOf(time) {
+        let lo = 0;
+        let hi = this.t.length - 1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            const v = this.t[mid];
+            if (v === time)
+                return mid;
+            if (v < time)
+                lo = mid + 1;
+            else
+                hi = mid - 1;
+        }
+        return -1;
+    }
+    push(k) {
+        this.t.push(k.t);
+        this.o.push(k.o);
+        this.h.push(k.h);
+        this.l.push(k.l);
+        this.c.push(k.c);
+    }
+    dropOldest(n) {
+        this.t.splice(0, n);
+        this.o.splice(0, n);
+        this.h.splice(0, n);
+        this.l.splice(0, n);
+        this.c.splice(0, n);
+        return n;
+    }
+}