@zuttora/charts 0.1.0 → 0.3.0

package/dist/render/indicatorFrame.d.ts

@@ -0,0 +1,17 @@
+import type { PriceRange } from '../core/priceScale.ts';
+import type { IndicatorEntry } from '../core/indicatorSet.ts';
+import type { Layout } from './frame.ts';
+export declare const SUB_PAD = 6;
+export declare const RSI_GUIDES: number[];
+export interface SubPane {
+    entry: IndicatorEntry;
+    top: number;
+    height: number;
+    min: number;
+    max: number;
+}
+export declare function subY(p: SubPane, v: number): number;
+export declare function subValueAt(p: SubPane, y: number): number;
+export declare function mainExtremes(entries: readonly IndicatorEntry[], from: number, to: number): PriceRange | null;
+export declare function buildSubPanes(entries: readonly IndicatorEntry[], layout: Layout, from: number, to: number): SubPane[];
+export declare function subTicks(p: SubPane, decimals: number): number[];

package/dist/render/indicatorFrame.js

@@ -0,0 +1,55 @@
+import { axisTicks } from "../core/priceScale.js";
+export const SUB_PAD = 6;
+export const RSI_GUIDES = [30, 70];
+export function subY(p, v) {
+    return p.top + SUB_PAD + ((p.max - v) / (p.max - p.min)) * Math.max(1, p.height - 2 * SUB_PAD);
+}
+export function subValueAt(p, y) {
+    return p.max - ((y - p.top - SUB_PAD) / Math.max(1, p.height - 2 * SUB_PAD)) * (p.max - p.min);
+}
+function scan(lists, from, to, into) {
+    for (const values of lists) {
+        for (let i = from; i <= to; i++) {
+            const v = values[i];
+            if (v === null || v === undefined)
+                continue;
+            if (v < into.min)
+                into.min = v;
+            if (v > into.max)
+                into.max = v;
+        }
+    }
+}
+export function mainExtremes(entries, from, to) {
+    const out = { min: Infinity, max: -Infinity };
+    for (const e of entries) {
+        const l = e.calc.lines;
+        scan(e.spec.type === 'bollinger' ? [l.upper, l.lower] : [l.main], from, to, out);
+    }
+    return out.min <= out.max ? out : null;
+}
+export function buildSubPanes(entries, layout, from, to) {
+    const panes = [];
+    entries.forEach((entry, i) => {
+        const slot = layout.subs[i];
+        if (!slot)
+            return;
+        let min = 0;
+        let max = 100;
+        if (entry.spec.type === 'macd') {
+            const l = entry.calc.lines;
+            const r = { min: 0, max: 0 };
+            scan([l.macd, l.signal, l.hist], from, to, r);
+            const pad = (r.max - r.min || 1) * 0.08;
+            min = r.min - pad;
+            max = r.max + pad;
+        }
+        panes.push({ entry, top: slot.top, height: slot.height, min, max });
+    });
+    return panes;
+}
+export function subTicks(p, decimals) {
+    if (p.entry.spec.type === 'rsi')
+        return RSI_GUIDES;
+    return axisTicks({ min: p.min, max: p.max }, p.height, 10 ** -(decimals + 2)).map((v) => v + 0);
+}

package/dist/render/paintFrame.js

@@ -1,5 +1,6 @@
 import { fitCanvas } from "./canvas.js";
 import { drawCrosshair } from "./drawCrosshair.js";
+import { drawDrawings } from "./drawDrawings.js";
 import { drawLastPrice, PULSE_MS } from "./drawLastPrice.js";
 import { drawMain } from "./drawMain.js";
 import { buildFrame } from "./frameBuilder.js";
@@ -14,6 +15,8 @@ export function paintFrame(s, t, flags, now) {
     const overlayCtx = fitCanvas(t.overlayCanvas, s.width, s.height, t.dpr());
     overlayCtx.clearRect(0, 0, s.width, s.height);
     s.pulses = s.pulses.filter((p) => now - p < PULSE_MS);
+    if (s.series.count > 0)
+        drawDrawings(overlayCtx, built.frame, { drawings: s.drawings, state: s.draw });
     if (s.series.forming) {
         drawLastPrice(overlayCtx, built.frame, {
             close: s.closeTween.value(now),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zuttora/charts",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Zuttora's own canvas charting package: candlesticks, square corners, no runtime dependencies.",
   "license": "MIT",
   "type": "module",