hyperprop-charting-library 0.1.131 → 0.1.133

package/dist/hyperprop-charting-library.js

@@ -603,14 +603,23 @@ var withCachedSeries = (key, data, compute) => {
   return values;
 };
 var builtInComputationCache = /* @__PURE__ */ new Map();
+var COMPUTATION_CACHE_MAX_ENTRIES = 128;
 var withCachedComputation = (key, data, compute) => {
   const fingerprint = getSeriesFingerprint(data);
   const existing = builtInComputationCache.get(key);
   if (existing && existing.fingerprint === fingerprint) {
+    builtInComputationCache.delete(key);
+    builtInComputationCache.set(key, existing);
     return existing.value;
   }
   const value = compute();
+  builtInComputationCache.delete(key);
   builtInComputationCache.set(key, { fingerprint, value });
+  while (builtInComputationCache.size > COMPUTATION_CACHE_MAX_ENTRIES) {
+    const oldest = builtInComputationCache.keys().next().value;
+    if (oldest === void 0) break;
+    builtInComputationCache.delete(oldest);
+  }
   return value;
 };
 var rollingExtremeSeries = (values, length, mode) => {
@@ -1468,6 +1477,495 @@ var drawSeparateMultiSeries = (ctx, renderContext, seriesList, options = {}) =>
   }
   return paneInfo;
 };
+var scriptRollingExtreme = (values, length, mode) => {
+  const fallback = mode === "max" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY;
+  const filled = new Array(values.length);
+  for (let i = 0; i < values.length; i += 1) {
+    const value = values[i];
+    filled[i] = value != null && Number.isFinite(value) ? value : fallback;
+  }
+  const raw = rollingExtremeSeries(filled, Math.max(1, Math.floor(length)), mode);
+  return raw.map((value) => value != null && Number.isFinite(value) ? value : null);
+};
+var scriptStdevSeries = (values, length) => {
+  const window2 = Math.max(1, Math.floor(length));
+  const result = new Array(values.length).fill(null);
+  let sum = 0;
+  let sumSq = 0;
+  let valid = 0;
+  for (let i = 0; i < values.length; i += 1) {
+    const value = values[i];
+    if (value == null || !Number.isFinite(value)) {
+      sum = 0;
+      sumSq = 0;
+      valid = 0;
+      continue;
+    }
+    sum += value;
+    sumSq += value * value;
+    valid += 1;
+    if (valid > window2) {
+      const old = values[i - window2];
+      sum -= old;
+      sumSq -= old * old;
+      valid -= 1;
+    }
+    if (valid === window2) {
+      const mean = sum / window2;
+      result[i] = Math.sqrt(Math.max(0, sumSq / window2 - mean * mean));
+    }
+  }
+  return result;
+};
+var scriptAtrSeries = (bars, length) => {
+  const tr = new Array(bars.length).fill(null);
+  for (let i = 0; i < bars.length; i += 1) {
+    const bar = bars[i];
+    if (i === 0) {
+      tr[i] = bar.h - bar.l;
+      continue;
+    }
+    const prevClose = bars[i - 1].c;
+    tr[i] = Math.max(bar.h - bar.l, Math.abs(bar.h - prevClose), Math.abs(bar.l - prevClose));
+  }
+  return rmaFromValues(tr, Math.max(1, Math.floor(length)));
+};
+var SCRIPT_HELPERS = Object.freeze({
+  sma: (values, length) => smaFromValues(values, Math.max(1, Math.floor(length))),
+  ema: (values, length) => emaFromValues(values, Math.max(1, Math.floor(length))),
+  rma: (values, length) => rmaFromValues(values, Math.max(1, Math.floor(length))),
+  highest: (values, length) => scriptRollingExtreme(values, length, "max"),
+  lowest: (values, length) => scriptRollingExtreme(values, length, "min"),
+  change: (values, length = 1) => values.map((value, index) => {
+    const prev = values[index - Math.max(1, Math.floor(length))];
+    return value != null && prev != null ? value - prev : null;
+  }),
+  stdev: scriptStdevSeries,
+  atr: scriptAtrSeries
+});
+var SCRIPT_PLOT_PALETTE = ["#2962ff", "#ff6d00", "#26a69a", "#ab47bc", "#ef5350", "#fdd835"];
+var hashScriptSource = (source) => {
+  let hash = 5381;
+  for (let i = 0; i < source.length; i += 1) {
+    hash = (hash << 5) + hash + source.charCodeAt(i) | 0;
+  }
+  return (hash >>> 0).toString(36);
+};
+var SCRIPT_GUARD_BUDGET_MS = 1e3;
+var ScriptBudgetError = class extends Error {
+  constructor() {
+    super(
+      `Script exceeded the ${SCRIPT_GUARD_BUDGET_MS}ms execution budget (possible infinite loop) \u2014 edit the script to retry`
+    );
+    this.name = "ScriptBudgetError";
+  }
+};
+var createScriptGuard = () => {
+  let deadline = Date.now() + SCRIPT_GUARD_BUDGET_MS;
+  let count = 0;
+  const guard = (() => {
+    count += 1;
+    if ((count & 1023) === 0 && Date.now() > deadline) {
+      throw new ScriptBudgetError();
+    }
+    return true;
+  });
+  guard.reset = () => {
+    count = 0;
+    deadline = Date.now() + SCRIPT_GUARD_BUDGET_MS;
+  };
+  return guard;
+};
+var injectLoopGuards = (source, guardName) => {
+  const n = source.length;
+  const isIdChar = (ch) => ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_" || ch === "$";
+  const scanString = (start) => {
+    const quote = source[start];
+    let j = start + 1;
+    while (j < n) {
+      const cj = source[j];
+      if (cj === "\\") {
+        j += 2;
+        continue;
+      }
+      if (cj === quote) {
+        return j + 1;
+      }
+      if (quote === "`" && cj === "$" && source[j + 1] === "{") {
+        let depth = 1;
+        j += 2;
+        while (j < n && depth > 0) {
+          const ce = source[j];
+          if (ce === "\\") {
+            j += 2;
+            continue;
+          }
+          if (ce === '"' || ce === "'" || ce === "`") {
+            j = scanString(j);
+            continue;
+          }
+          if (ce === "{") depth += 1;
+          else if (ce === "}") depth -= 1;
+          j += 1;
+        }
+        continue;
+      }
+      j += 1;
+    }
+    return n;
+  };
+  const scanRegex = (start) => {
+    let j = start + 1;
+    let inClass = false;
+    while (j < n) {
+      const cj = source[j];
+      if (cj === "\\") {
+        j += 2;
+        continue;
+      }
+      if (cj === "\n") return j;
+      if (cj === "[") inClass = true;
+      else if (cj === "]") inClass = false;
+      else if (cj === "/" && !inClass) return j + 1;
+      j += 1;
+    }
+    return n;
+  };
+  const skipWsAndComments = (k) => {
+    let j = k;
+    while (j < n) {
+      const cj = source[j];
+      if (cj === " " || cj === "	" || cj === "\n" || cj === "\r") {
+        j += 1;
+        continue;
+      }
+      if (cj === "/" && source[j + 1] === "/") {
+        const nl = source.indexOf("\n", j);
+        j = nl === -1 ? n : nl + 1;
+        continue;
+      }
+      if (cj === "/" && source[j + 1] === "*") {
+        const end = source.indexOf("*/", j + 2);
+        j = end === -1 ? n : end + 2;
+        continue;
+      }
+      return j;
+    }
+    return n;
+  };
+  const matchParen = (openIdx) => {
+    let depth = 0;
+    let j = openIdx;
+    while (j < n) {
+      const cj = source[j];
+      if (cj === '"' || cj === "'" || cj === "`") {
+        j = scanString(j);
+        continue;
+      }
+      if (cj === "/" && source[j + 1] === "/") {
+        const nl = source.indexOf("\n", j);
+        j = nl === -1 ? n : nl + 1;
+        continue;
+      }
+      if (cj === "/" && source[j + 1] === "*") {
+        const end = source.indexOf("*/", j + 2);
+        j = end === -1 ? n : end + 2;
+        continue;
+      }
+      if (cj === "(") depth += 1;
+      else if (cj === ")") {
+        depth -= 1;
+        if (depth === 0) return j;
+      }
+      j += 1;
+    }
+    return -1;
+  };
+  const splitTopLevelSemicolons = (inner) => {
+    const parts = [];
+    let depth = 0;
+    let j = 0;
+    let last = 0;
+    const m = inner.length;
+    while (j < m) {
+      const cj = inner[j];
+      if (cj === '"' || cj === "'" || cj === "`") {
+        const quote = cj;
+        j += 1;
+        while (j < m) {
+          if (inner[j] === "\\") {
+            j += 2;
+            continue;
+          }
+          if (inner[j] === quote) {
+            j += 1;
+            break;
+          }
+          j += 1;
+        }
+        continue;
+      }
+      if (cj === "(" || cj === "[" || cj === "{") depth += 1;
+      else if (cj === ")" || cj === "]" || cj === "}") depth -= 1;
+      else if (cj === ";" && depth === 0) {
+        parts.push(inner.slice(last, j));
+        last = j + 1;
+      }
+      j += 1;
+    }
+    parts.push(inner.slice(last));
+    return parts;
+  };
+  const REGEX_PRECEDING_WORDS = /* @__PURE__ */ new Set([
+    "return",
+    "typeof",
+    "case",
+    "do",
+    "else",
+    "in",
+    "of",
+    "new",
+    "delete",
+    "void",
+    "instanceof",
+    "yield",
+    "await"
+  ]);
+  let out = "";
+  let i = 0;
+  let lastSig = "";
+  let lastWord = "";
+  while (i < n) {
+    const ch = source[i];
+    if (ch === "/" && source[i + 1] === "/") {
+      const nl = source.indexOf("\n", i);
+      const end = nl === -1 ? n : nl;
+      out += source.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "*") {
+      const close = source.indexOf("*/", i + 2);
+      const end = close === -1 ? n : close + 2;
+      out += source.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const end = scanString(i);
+      out += source.slice(i, end);
+      lastSig = ch;
+      lastWord = "";
+      i = end;
+      continue;
+    }
+    if (ch === "/") {
+      const regexLikely = lastSig === "" || "(,=:;!&|?{}[+-*%~^<>".includes(lastSig) || REGEX_PRECEDING_WORDS.has(lastWord);
+      if (regexLikely) {
+        const end = scanRegex(i);
+        out += source.slice(i, end);
+        lastSig = "/";
+        lastWord = "";
+        i = end;
+        continue;
+      }
+      out += ch;
+      lastSig = ch;
+      lastWord = "";
+      i += 1;
+      continue;
+    }
+    if (isIdChar(ch)) {
+      let j = i;
+      while (j < n && isIdChar(source[j])) j += 1;
+      const word = source.slice(i, j);
+      if ((word === "while" || word === "for") && lastSig !== ".") {
+        const k = skipWsAndComments(j);
+        if (source[k] === "(") {
+          const close = matchParen(k);
+          if (close !== -1) {
+            const inner = source.slice(k + 1, close);
+            if (word === "while") {
+              out += `while (${guardName}() && (${inner}))`;
+              lastSig = ")";
+              lastWord = "";
+              i = close + 1;
+              continue;
+            }
+            const parts = splitTopLevelSemicolons(inner);
+            if (parts.length === 3) {
+              const cond = parts[1].trim();
+              const guardedCond = cond ? `${guardName}() && (${cond})` : `${guardName}()`;
+              out += `for (${parts[0]}; ${guardedCond}; ${parts[2]})`;
+              lastSig = ")";
+              lastWord = "";
+              i = close + 1;
+              continue;
+            }
+            out += source.slice(i, close + 1);
+            lastSig = ")";
+            lastWord = "";
+            i = close + 1;
+            continue;
+          }
+        }
+      }
+      out += word;
+      lastSig = word[word.length - 1];
+      lastWord = word;
+      i = j;
+      continue;
+    }
+    out += ch;
+    if (ch !== " " && ch !== "	" && ch !== "\n" && ch !== "\r") {
+      lastSig = ch;
+      lastWord = "";
+    }
+    i += 1;
+  }
+  return out;
+};
+var compileScriptCompute = (source, guard) => {
+  const makeFactory = (body) => new Function(
+    "__hpGuard",
+    `"use strict";
+${body}
+;if (typeof compute !== "function") { throw new Error("Script must define function compute(bars, inputs, hp)"); }
+return compute;`
+  );
+  let factory;
+  try {
+    factory = makeFactory(injectLoopGuards(source, "__hpGuard"));
+  } catch {
+    factory = makeFactory(source);
+  }
+  guard.reset();
+  return factory(guard);
+};
+var validateScriptSource = (source) => {
+  try {
+    compileScriptCompute(source, createScriptGuard());
+    return null;
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+};
+var drawScriptError = (ctx, renderContext, name, message) => {
+  ctx.save();
+  ctx.font = "11px -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif";
+  ctx.textAlign = "left";
+  ctx.textBaseline = "top";
+  ctx.fillStyle = "#ef5350";
+  const text = `${name}: ${message}`.slice(0, 160);
+  ctx.fillText(text, renderContext.chartLeft + 10, renderContext.chartTop + 24);
+  ctx.restore();
+};
+var compileScriptIndicator = (definition) => {
+  const pane = definition.pane ?? "separate";
+  const defaultInputs = { showValueLine: true };
+  for (const input of definition.inputs ?? []) {
+    defaultInputs[input.key] = input.default;
+  }
+  let compiled = null;
+  let compileError = null;
+  const guard = createScriptGuard();
+  try {
+    compiled = compileScriptCompute(definition.source, guard);
+  } catch (error) {
+    compileError = error instanceof Error ? error.message : String(error);
+  }
+  const sourceKey = hashScriptSource(definition.source);
+  let trippedError = null;
+  const runCompute = (data, inputs) => {
+    if (!compiled) {
+      return { error: compileError ?? "Script failed to compile" };
+    }
+    if (trippedError) {
+      return { error: trippedError };
+    }
+    try {
+      guard.reset();
+      const result = compiled(data, inputs, SCRIPT_HELPERS);
+      if (!result || !Array.isArray(result.plots)) {
+        return { error: "compute() must return { plots: [...] }" };
+      }
+      for (const plot of result.plots) {
+        if (!plot || !Array.isArray(plot.values)) {
+          return { error: "Every plot needs a `values` array" };
+        }
+      }
+      return { result };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (error instanceof ScriptBudgetError) {
+        trippedError = message;
+      }
+      return { error: message };
+    }
+  };
+  const cachedCompute = (data, inputs) => withCachedComputation(
+    `script|${definition.id}|${sourceKey}|${JSON.stringify(inputs)}`,
+    data,
+    () => runCompute(data, inputs)
+  );
+  const plugin = {
+    id: definition.id,
+    name: definition.name,
+    pane,
+    defaultInputs,
+    draw: (ctx, renderContext, inputs) => {
+      const outcome = cachedCompute(renderContext.data, inputs);
+      if (!outcome.result) {
+        drawScriptError(ctx, renderContext, definition.name, outcome.error ?? "Unknown script error");
+        return pane === "separate" ? { title: `${definition.name} (script error)` } : void 0;
+      }
+      const { plots, range, guides, decimals } = outcome.result;
+      if (pane === "separate") {
+        const seriesList = plots.map((plot, index) => ({
+          values: plot.values,
+          color: plot.color ?? SCRIPT_PLOT_PALETTE[index % SCRIPT_PLOT_PALETTE.length],
+          ...plot.width !== void 0 ? { width: plot.width } : {},
+          ...plot.title ? { label: plot.title } : {},
+          ...plot.style === "histogram" ? { histogram: true } : {},
+          ...plot.negativeColor ? { negativeColor: plot.negativeColor } : {}
+        }));
+        return drawSeparateMultiSeries(ctx, renderContext, seriesList, {
+          title: definition.name,
+          ...range?.min !== void 0 ? { minOverride: range.min } : {},
+          ...range?.max !== void 0 ? { maxOverride: range.max } : {},
+          ...guides && guides.length > 0 ? { guideLines: guides } : {},
+          ...decimals !== void 0 ? { decimals } : {},
+          valueLines: inputs.showValueLine !== false
+        });
+      }
+      for (let index = 0; index < plots.length; index += 1) {
+        const plot = plots[index];
+        if (plot.style === "histogram") continue;
+        drawOverlaySeries(
+          ctx,
+          renderContext,
+          plot.values,
+          plot.color ?? SCRIPT_PLOT_PALETTE[index % SCRIPT_PLOT_PALETTE.length],
+          plot.width ?? 2
+        );
+      }
+      return void 0;
+    },
+    ...pane === "overlay" ? {
+      getAutoscaleRange: (data, startIndex, endIndex, inputs, skipIndex) => {
+        const outcome = cachedCompute(data, inputs);
+        if (!outcome.result) return null;
+        const lineSeries = outcome.result.plots.filter((plot) => plot.style !== "histogram").map((plot) => plot.values);
+        if (lineSeries.length === 0) return null;
+        return rangeOfSeries(lineSeries, startIndex, endIndex, skipIndex);
+      }
+    } : {}
+  };
+  if (definition.paneHeightRatio !== void 0) {
+    plugin.paneHeightRatio = definition.paneHeightRatio;
+  }
+  return plugin;
+};
 var computeMacd = (data, fast, slow, signalLength) => {
   const fastEma = computeEmaSeries(data, fast, "close");
   const slowEma = computeEmaSeries(data, slow, "close");
@@ -2519,7 +3017,7 @@ function createChart(element, options = {}) {
       return;
     }
     const tickerOpts = mergedOptions.tickerLine ?? DEFAULT_OPTIONS.tickerLine;
-    const speed = clamp(tickerOpts.smoothingSpeed ?? 4, 1, 60);
+    const speed = clamp(tickerOpts.smoothingSpeed ?? 16, 1, 60);
     const dt = 1 / 60;
     const lerp = 1 - Math.exp(-speed * dt);
     smoothedTickerPrice += priceDiff * lerp;
@@ -2549,6 +3047,29 @@ function createChart(element, options = {}) {
       smoothingRafId = requestAnimationFrame(tickerSmoothingLoop);
     }
   };
+  let countdownTimerId = null;
+  const countdownRepaintNeeded = () => {
+    if (data.length === 0) {
+      return false;
+    }
+    const ticker = mergedOptions.tickerLine ?? DEFAULT_OPTIONS.tickerLine;
+    const labels = mergedOptions.labels ?? DEFAULT_OPTIONS.labels;
+    return Boolean(ticker.showCountdownInLabel) || Boolean(labels.visible && labels.showCountdownToBarClose);
+  };
+  const armCountdownHeartbeat = () => {
+    if (countdownTimerId !== null || !countdownRepaintNeeded()) {
+      return;
+    }
+    const delay = 1e3 - Date.now() % 1e3 + 15;
+    countdownTimerId = setTimeout(() => {
+      countdownTimerId = null;
+      if (!countdownRepaintNeeded()) {
+        return;
+      }
+      scheduleDraw({ updateAutoScale: false });
+      armCountdownHeartbeat();
+    }, delay);
+  };
   const canvas = document.createElement("canvas");
   const ctx = canvas.getContext("2d");
   if (!ctx) {
@@ -3474,6 +3995,7 @@ function createChart(element, options = {}) {
   let pendingDrawUpdateAutoScale = false;
   let pendingDrawOverlayOnly = true;
   const scheduleDraw = (options2 = {}) => {
+    armCountdownHeartbeat();
     const overlayOnly = options2.overlayOnly ?? false;
     pendingDrawOverlayOnly = pendingDrawOverlayOnly && overlayOnly;
     pendingDrawUpdateAutoScale = pendingDrawUpdateAutoScale || !overlayOnly && (options2.updateAutoScale ?? true);
@@ -7731,6 +8253,10 @@ function createChart(element, options = {}) {
       cancelAnimationFrame(smoothingRafId);
       smoothingRafId = null;
     }
+    if (countdownTimerId !== null) {
+      clearTimeout(countdownTimerId);
+      countdownTimerId = null;
+    }
     if (drawRafId !== null) {
       cancelAnimationFrame(drawRafId);
       drawRafId = null;
@@ -7752,6 +8278,7 @@ function createChart(element, options = {}) {
     element.innerHTML = "";
   };
   draw();
+  armCountdownHeartbeat();
   return {
     updateOptions,
     setChartType,
@@ -7821,5 +8348,7 @@ function createChart(element, options = {}) {
 export {
   FIB_DEFAULT_PALETTE,
   POSITION_DEFAULT_COLORS,
-  createChart
+  compileScriptIndicator,
+  createChart,
+  validateScriptSource
 };