chartforge 0.0.2 → 0.1.0

package/cli/dist/writer-CRUdthqh.cjs

@@ -0,0 +1,697 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+const index = require("./index-BtGYSrj-.cjs");
+const jsdom = require("jsdom");
+const fs = require("fs");
+const path = require("path");
+function parseJSON(raw, jq) {
+  let obj = JSON.parse(raw);
+  if (jq) {
+    for (const key of jq.split(".")) {
+      if (obj && typeof obj === "object" && key in obj) {
+        obj = obj[key];
+      } else {
+        throw new Error(`jq path "${jq}" not found in response`);
+      }
+    }
+  }
+  if (isChartShape(obj)) return obj;
+  if (Array.isArray(obj) && obj.every((v) => typeof v === "number")) {
+    return { series: [{ name: "Series 1", data: obj }] };
+  }
+  if (Array.isArray(obj) && obj.length && typeof obj[0] === "object") {
+    return parseObjectArray(obj);
+  }
+  if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
+    const entries = Object.entries(obj);
+    return {
+      labels: entries.map(([k]) => k),
+      series: [{ name: "Series 1", data: entries.map(([, v]) => Number(v)) }]
+    };
+  }
+  throw new Error("Could not auto-detect data shape from JSON. Use ChartForge shape: { series: [{ data: [] }] }");
+}
+function isChartShape(obj) {
+  return typeof obj === "object" && obj !== null && "series" in obj && Array.isArray(obj["series"]);
+}
+function parseObjectArray(arr) {
+  const labelKeys = ["label", "name", "x", "key", "category", "date", "month"];
+  const valueKeys = ["value", "y", "v", "count", "total", "amount", "sales", "revenue"];
+  const labelKey = labelKeys.find((k) => k in arr[0]);
+  const valueKey = valueKeys.find((k) => k in arr[0]);
+  if (!valueKey) {
+    throw new Error(`Cannot find a value field. Tried: ${valueKeys.join(", ")}`);
+  }
+  return {
+    labels: labelKey ? arr.map((r) => String(r[labelKey])) : void 0,
+    series: [{ name: "Series 1", data: arr.map((r) => Number(r[valueKey])) }]
+  };
+}
+function parseCSV(raw, delimiter = ",") {
+  const lines = raw.trim().split("\n").filter(Boolean);
+  if (!lines.length) throw new Error("CSV is empty");
+  const header = lines[0].split(delimiter).map((h) => h.trim().replace(/^"|"$/g, ""));
+  const rows = lines.slice(1).map(
+    (l) => l.split(delimiter).map((v) => v.trim().replace(/^"|"$/g, ""))
+  );
+  const isNumericCol = (ci) => rows.every((r) => r[ci] === "" || !isNaN(Number(r[ci])));
+  let labelColIdx = -1;
+  if (!isNumericCol(0)) labelColIdx = 0;
+  const valueCols = header.map((_, ci) => ci).filter((ci) => ci !== labelColIdx && isNumericCol(ci));
+  return {
+    labels: labelColIdx >= 0 ? rows.map((r) => r[labelColIdx]) : void 0,
+    series: valueCols.map((ci) => ({
+      name: header[ci],
+      data: rows.map((r) => r[ci] === "" ? 0 : Number(r[ci]))
+    }))
+  };
+}
+function parseTSV(raw) {
+  return parseCSV(raw, "	");
+}
+function parseYAML(raw) {
+  const lines = raw.split("\n");
+  const obj = {};
+  let current = obj;
+  for (let line of lines) {
+    line = line.trimEnd();
+    if (!line || line.startsWith("#")) continue;
+    const match = line.match(/^(\s*)(\w[\w\s]*):\s*(.*)/);
+    if (!match) continue;
+    const [, , key, value] = match;
+    const trimKey = key.trim();
+    if (value.startsWith("[")) {
+      try {
+        current[trimKey] = JSON.parse(value);
+      } catch {
+        current[trimKey] = value;
+      }
+    } else if (value !== "") {
+      const num = Number(value);
+      current[trimKey] = isNaN(num) ? value.replace(/^['"]|['"]$/g, "") : num;
+    }
+  }
+  if (isChartShape(obj)) return obj;
+  return parseJSON(JSON.stringify(obj));
+}
+function parseInput(raw, format) {
+  const fmt = (format ?? "").toLowerCase();
+  if (fmt === "tsv") return parseTSV(raw);
+  if (fmt === "csv") return parseCSV(raw);
+  if (fmt === "yaml" || fmt === "yml") return parseYAML(raw);
+  const trimmed = raw.trimStart();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) return parseJSON(raw);
+  if (trimmed.includes("	")) return parseTSV(raw);
+  return parseCSV(raw);
+}
+const parser = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  parseCSV,
+  parseInput,
+  parseJSON,
+  parseTSV,
+  parseYAML
+}, Symbol.toStringTag, { value: "Module" }));
+async function fetchData(opts) {
+  const { url, method = "GET", headers = {}, body, jq, timeout = 15e3 } = opts;
+  index.logger.step(`Fetching ${method} ${url}`);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const res = await fetch(url, {
+      method,
+      headers: { "Accept": "application/json", ...headers },
+      body: body && method !== "GET" ? body : void 0,
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status} ${res.statusText} from ${url}`);
+    }
+    const contentType = res.headers.get("content-type") ?? "";
+    let raw;
+    if (contentType.includes("json")) {
+      raw = await res.text();
+    } else if (contentType.includes("csv") || contentType.includes("text/plain")) {
+      const { parseCSV: parseCSV2 } = await Promise.resolve().then(() => parser);
+      raw = await res.text();
+      return parseCSV2(raw);
+    } else {
+      raw = await res.text();
+    }
+    return parseJSON(raw, jq);
+  } catch (err) {
+    clearTimeout(timer);
+    if (err.name === "AbortError") {
+      throw new Error(`Request to ${url} timed out after ${timeout}ms`);
+    }
+    throw err;
+  }
+}
+async function pollData(opts, interval, callback, signal) {
+  let tick = 0;
+  const run = async () => {
+    try {
+      const data = await fetchData(opts);
+      await callback(data, tick++);
+    } catch (err) {
+      index.logger.error("Poll fetch failed", err);
+    }
+  };
+  await run();
+  await new Promise((resolve) => {
+    const id = setInterval(async () => {
+      if (signal?.aborted) {
+        clearInterval(id);
+        resolve();
+        return;
+      }
+      await run();
+    }, interval * 1e3);
+    signal?.addEventListener("abort", () => {
+      clearInterval(id);
+      resolve();
+    });
+  });
+}
+const BRAILLE_OFFSET = 10240;
+const BRAILLE_DOTS = [1, 8, 2, 16, 4, 32, 64, 128];
+const USE_COLOR = !process.env["NO_COLOR"] && process.stdout.isTTY;
+const c = (code, s) => USE_COLOR ? `\x1B[${code}m${s}\x1B[0m` : s;
+const COLORS = ["36", "33", "32", "35", "34", "31", "37", "90"];
+const seriesColor = (i, s) => c(COLORS[i % COLORS.length], s);
+const BLOCKS = ["▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"];
+const FULL = "█";
+function barChart(data, termWidth = 80) {
+  const lines = [];
+  const series = data.series[0];
+  if (!series) return "(no data)";
+  const values = series.data;
+  const labels = data.labels ?? values.map((_, i) => String(i + 1));
+  const maxVal = Math.max(...values.filter((v) => isFinite(v)));
+  const maxLbl = Math.max(...labels.map((l) => l.length));
+  const barW = Math.max(20, Math.min(50, termWidth - maxLbl - 18));
+  const formatVal = (v) => {
+    if (v >= 1e6) return `${(v / 1e6).toFixed(1)}M`;
+    if (v >= 1e3) return `${(v / 1e3).toFixed(1)}k`;
+    return String(v);
+  };
+  for (let i = 0; i < values.length; i++) {
+    const val = values[i];
+    const lbl = labels[i].padStart(maxLbl);
+    const ratio = maxVal > 0 ? val / maxVal : 0;
+    const full = Math.floor(ratio * barW);
+    const part = Math.floor((ratio * barW - full) * 8);
+    const bar = FULL.repeat(full) + (part > 0 ? BLOCKS[part - 1] : "");
+    const blank = " ".repeat(Math.max(0, barW - full - (part > 0 ? 1 : 0)));
+    const valStr = formatVal(val).padStart(8);
+    lines.push(
+      `  ${c("90", lbl)} ${seriesColor(0, bar)}${c("90", blank)} ${c("2", valStr)}`
+    );
+  }
+  return lines.join("\n");
+}
+const SPARK = "▁▂▃▄▅▆▇█";
+function sparkline(values) {
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const rng = max - min || 1;
+  return values.map((v) => {
+    const idx = Math.round((v - min) / rng * (SPARK.length - 1));
+    return SPARK[idx];
+  }).join("");
+}
+function brailleChart(data, cols = 60, rows = 16) {
+  const canvas = Array.from(
+    { length: rows * 4 },
+    () => new Array(cols * 2).fill(0)
+  );
+  const allVals = data.series.flatMap((s) => s.data);
+  const minVal = Math.min(...allVals);
+  const maxVal = Math.max(...allVals);
+  const rng = maxVal - minVal || 1;
+  data.series.forEach((s, si) => {
+    const vals = s.data;
+    for (let i = 0; i < vals.length - 1; i++) {
+      const x1 = Math.round(i / (vals.length - 1) * (cols * 2 - 1));
+      const x2 = Math.round((i + 1) / (vals.length - 1) * (cols * 2 - 1));
+      const y1 = Math.round((vals[i] - minVal) / rng * (rows * 4 - 1));
+      const y2 = Math.round((vals[i + 1] - minVal) / rng * (rows * 4 - 1));
+      let dx = x2 - x1, dy = y2 - y1;
+      const sx = dx > 0 ? 1 : -1, sy = dy > 0 ? 1 : -1;
+      dx = Math.abs(dx);
+      dy = Math.abs(dy);
+      let err = dx - dy, cx = x1, cy = y1;
+      while (true) {
+        const px = cx, py = rows * 4 - 1 - cy;
+        if (px >= 0 && px < cols * 2 && py >= 0 && py < rows * 4) {
+          canvas[py][px] = si + 1;
+        }
+        if (cx === x2 && cy === y2) break;
+        const e2 = 2 * err;
+        if (e2 > -dy) {
+          err -= dy;
+          cx += sx;
+        }
+        if (e2 < dx) {
+          err += dx;
+          cy += sy;
+        }
+      }
+    }
+  });
+  const brailleLines = [];
+  for (let row = 0; row < rows; row++) {
+    let line = "  ";
+    for (let col = 0; col < cols; col++) {
+      let char = BRAILLE_OFFSET;
+      let si = 0;
+      for (let dy = 0; dy < 4; dy++) {
+        for (let dx = 0; dx < 2; dx++) {
+          const px = col * 2 + dx;
+          const py = row * 4 + dy;
+          const sv = canvas[py]?.[px] ?? 0;
+          if (sv) {
+            char |= BRAILLE_DOTS[dy * 2 + dx];
+            si = sv - 1;
+          }
+        }
+      }
+      const ch = String.fromCharCode(char);
+      line += char === BRAILLE_OFFSET ? " " : seriesColor(si, ch);
+    }
+    brailleLines.push(line);
+  }
+  return brailleLines.join("\n");
+}
+function yAxis(values, height = 16) {
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const fmt = (v) => {
+    if (Math.abs(v) >= 1e6) return `${(v / 1e6).toFixed(1)}M`;
+    if (Math.abs(v) >= 1e3) return `${(v / 1e3).toFixed(1)}k`;
+    return v.toFixed(1);
+  };
+  const lines = [];
+  for (let i = 0; i < height; i++) {
+    const v = max - i / (height - 1) * (max - min);
+    lines.push(i % 4 === 0 ? c("90", fmt(v).padStart(8)) : " ".repeat(8));
+  }
+  return lines;
+}
+function legend(data) {
+  return data.series.map((s, i) => seriesColor(i, `  ● ${s.name ?? `Series ${i + 1}`}`)).join("   ");
+}
+function renderToTerminal(data, opts = {}) {
+  const termW = opts.width ?? Math.min(process.stdout.columns ?? 80, 100);
+  const type = opts.type ?? "column";
+  const lines = [];
+  if (opts.title) {
+    lines.push("");
+    lines.push(`  ${c("1", opts.title)}`);
+    lines.push(`  ${c("90", "─".repeat(Math.min(opts.title.length + 2, termW - 4)))}`);
+  }
+  lines.push("");
+  if (type === "line" || type === "scatter") {
+    const allVals2 = data.series.flatMap((s) => s.data);
+    const yLabels = yAxis(allVals2);
+    const braille = brailleChart(data, Math.max(30, Math.floor((termW - 12) / 2)));
+    const brailleLines = braille.split("\n");
+    brailleLines.forEach((bl, i) => {
+      lines.push((yLabels[i] ?? " ".repeat(8)) + c("90", " │") + bl);
+    });
+    lines.push(" ".repeat(9) + c("90", "└" + "─".repeat(termW - 11)));
+    if (data.labels?.length) {
+      const step = Math.max(1, Math.floor(data.labels.length / 8));
+      const xLine = data.labels.filter((_, i) => i % step === 0).map((l) => l.substring(0, 8).padEnd(9)).join("");
+      lines.push(c("90", "         " + xLine));
+    }
+  } else if (type === "pie" || type === "donut") {
+    const vals = data.series[0]?.data ?? [];
+    const labels = data.labels ?? vals.map((_, i) => `Slice ${i + 1}`);
+    const total = vals.reduce((s, v) => s + v, 0);
+    const barW = Math.min(40, termW - 30);
+    for (let i = 0; i < vals.length; i++) {
+      const pct = total > 0 ? vals[i] / total : 0;
+      const fill = Math.round(pct * barW);
+      const bar = "█".repeat(fill) + c("90", "░".repeat(barW - fill));
+      lines.push(
+        `  ${seriesColor(i, labels[i].padEnd(15).substring(0, 15))} ${seriesColor(i, bar)} ${c("1", (pct * 100).toFixed(1))}%`
+      );
+    }
+  } else if (type === "bar") {
+    lines.push(barChart({ ...data, series: data.series }, termW));
+  } else {
+    lines.push(barChart(data, termW));
+  }
+  lines.push("");
+  data.series.forEach((s, i) => {
+    const spark = sparkline(s.data);
+    lines.push(`  ${seriesColor(i, `${s.name ?? `Series ${i + 1}`}:`).padEnd(20)} ${seriesColor(i, spark)}`);
+  });
+  if (data.series.length > 1) {
+    lines.push("");
+    lines.push(legend(data));
+  }
+  const allVals = data.series.flatMap((s) => s.data).filter(isFinite);
+  const min = Math.min(...allVals);
+  const max = Math.max(...allVals);
+  const avg = allVals.reduce((s, v) => s + v, 0) / allVals.length;
+  lines.push("");
+  lines.push(c("90", [
+    `  Min: ${min.toLocaleString()}`,
+    `Max: ${max.toLocaleString()}`,
+    `Avg: ${avg.toFixed(2)}`,
+    `Points: ${allVals.length}`
+  ].join("   ")));
+  lines.push("");
+  return lines.join("\n");
+}
+let _shimmed = false;
+function shimBrowser() {
+  if (_shimmed) return;
+  _shimmed = true;
+  const dom = new jsdom.JSDOM('<!DOCTYPE html><html><body><div id="root"></div></body></html>', {
+    pretendToBeVisual: true
+  });
+  const { window } = dom;
+  Object.assign(globalThis, {
+    window,
+    document: window.document,
+    navigator: window.navigator,
+    SVGElement: window.SVGElement,
+    SVGSVGElement: window.SVGSVGElement,
+    HTMLElement: window.HTMLElement,
+    Element: window.Element,
+    Event: window.Event,
+    MouseEvent: window.MouseEvent,
+    CustomEvent: window.CustomEvent,
+    MutationObserver: window.MutationObserver,
+    ResizeObserver: class MockResizeObserver {
+      observe() {
+      }
+      unobserve() {
+      }
+      disconnect() {
+      }
+    },
+    requestAnimationFrame: (cb) => setTimeout(() => cb(performance.now()), 0),
+    cancelAnimationFrame: (id) => clearTimeout(id),
+    performance: globalThis.performance ?? { now: Date.now.bind(Date) }
+  });
+}
+async function renderToSVG(data, opts) {
+  shimBrowser();
+  const { ChartForge } = await Promise.resolve().then(() => require("./ChartForge-BMKdVldJ.cjs"));
+  const { BUILT_IN_THEMES } = await Promise.resolve().then(() => require("./builtins-5HYzyd_B.cjs"));
+  const width = opts.width ?? 800;
+  const height = opts.height ?? 450;
+  const theme = opts.theme ?? "dark";
+  const container = globalThis.document.createElement("div");
+  container.style.width = `${width}px`;
+  container.style.height = `${height}px`;
+  globalThis.document.body.appendChild(container);
+  const chart = new ChartForge(container, {
+    type: opts.type ?? "column",
+    theme,
+    width,
+    height,
+    responsive: false,
+    animation: { enabled: false },
+    // always disable for static export
+    data: {
+      labels: opts.labels ? opts.labels.split(",").map((l) => l.trim()) : data.labels,
+      series: data.series
+    }
+  });
+  const noAxis = ["pie", "donut", "funnel", "heatmap"];
+  if (!noAxis.includes(opts.type ?? "column")) {
+    const { AxisPlugin } = await Promise.resolve().then(() => require("./AxisPlugin-Cge0pH5P.cjs"));
+    const { GridPlugin } = await Promise.resolve().then(() => require("./GridPlugin-C90wMQsN.cjs"));
+    chart.use("axis", AxisPlugin);
+    chart.use("grid", GridPlugin);
+  }
+  await new Promise((r) => setTimeout(r, 80));
+  const svg = container.querySelector("svg");
+  if (!svg) throw new Error("Renderer produced no SVG element");
+  chart.themeManager.get(theme) ?? BUILT_IN_THEMES["dark"];
+  const style = globalThis.document.createElementNS("http://www.w3.org/2000/svg", "style");
+  style.textContent = `
+    .chartforge-svg { font-family: 'Segoe UI', system-ui, sans-serif; }
+    text { font-family: inherit; }
+  `;
+  svg.insertBefore(style, svg.firstChild);
+  if (!svg.getAttribute("viewBox")) {
+    svg.setAttribute("viewBox", `0 0 ${width} ${height}`);
+  }
+  svg.setAttribute("width", String(width));
+  svg.setAttribute("height", String(height));
+  svg.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+  const svgStr = svg.outerHTML;
+  chart.destroy();
+  globalThis.document.body.removeChild(container);
+  return { svg: svgStr, width, height };
+}
+function generateHTML(svgResult, data, opts) {
+  const title = opts.title ?? "ChartForge Export";
+  const theme = opts.theme ?? "dark";
+  const isDark = theme !== "light";
+  const bg = isDark ? "#0f0f13" : "#f8f9fa";
+  const surface = isDark ? "#18181f" : "#ffffff";
+  const border = isDark ? "#2a2a35" : "#e5e7eb";
+  const text = isDark ? "#e2e2f0" : "#111827";
+  const muted = isDark ? "#6b6b80" : "#6b7280";
+  const accent = "#6366f1";
+  const now = (/* @__PURE__ */ new Date()).toLocaleString();
+  const stats = buildStats(data);
+  return `<!DOCTYPE html>
+<html lang="en" data-theme="${theme}">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>${escHtml(title)}</title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+    :root {
+      --bg:      ${bg};
+      --surface: ${surface};
+      --border:  ${border};
+      --text:    ${text};
+      --muted:   ${muted};
+      --accent:  ${accent};
+    }
+
+    body {
+      font-family: 'Segoe UI', system-ui, -apple-system, sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      min-height: 100vh;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      padding: 2rem 1rem;
+    }
+
+    .container {
+      width: 100%;
+      max-width: 960px;
+    }
+
+    header {
+      margin-bottom: 1.5rem;
+      display: flex;
+      align-items: flex-start;
+      justify-content: space-between;
+      flex-wrap: wrap;
+      gap: .5rem;
+    }
+
+    .title-group h1 {
+      font-size: 1.5rem;
+      font-weight: 700;
+      letter-spacing: -.02em;
+    }
+
+    .title-group p {
+      color: var(--muted);
+      font-size: .8rem;
+      margin-top: .25rem;
+    }
+
+    .badge {
+      font-size: .7rem;
+      padding: .25rem .6rem;
+      background: color-mix(in srgb, var(--accent) 15%, transparent);
+      color: var(--accent);
+      border: 1px solid color-mix(in srgb, var(--accent) 30%, transparent);
+      border-radius: 9999px;
+      font-weight: 600;
+      white-space: nowrap;
+      align-self: flex-start;
+      margin-top: .2rem;
+    }
+
+    .chart-card {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 16px;
+      padding: 1.5rem;
+      margin-bottom: 1.5rem;
+      box-shadow: 0 4px 24px rgba(0,0,0,.12);
+    }
+
+    .chart-card svg {
+      width: 100%;
+      height: auto;
+      display: block;
+    }
+
+    .stats-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+      gap: 1rem;
+      margin-bottom: 1.5rem;
+    }
+
+    .stat-card {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 12px;
+      padding: 1rem 1.25rem;
+    }
+
+    .stat-card .label {
+      font-size: .75rem;
+      color: var(--muted);
+      text-transform: uppercase;
+      letter-spacing: .06em;
+      margin-bottom: .35rem;
+    }
+
+    .stat-card .value {
+      font-size: 1.5rem;
+      font-weight: 700;
+      color: var(--text);
+    }
+
+    .meta {
+      font-size: .75rem;
+      color: var(--muted);
+      text-align: center;
+      margin-top: 1rem;
+    }
+
+    .meta a { color: var(--accent); text-decoration: none; }
+    .meta a:hover { text-decoration: underline; }
+
+    @media (max-width: 600px) {
+      .stats-grid { grid-template-columns: 1fr 1fr; }
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <div class="title-group">
+        <h1>${escHtml(title)}</h1>
+        <p>Generated by ChartForge CLI · ${escHtml(now)}</p>
+      </div>
+      <span class="badge">⬡ ChartForge</span>
+    </header>
+
+    <div class="chart-card">
+      ${svgResult.svg}
+    </div>
+
+    <div class="stats-grid">
+      ${stats.map((s) => `
+      <div class="stat-card">
+        <div class="label">${escHtml(s.label)}</div>
+        <div class="value">${escHtml(s.value)}</div>
+      </div>`).join("")}
+    </div>
+
+    <p class="meta">
+      Rendered with <a href="https://github.com/anandpilania/chartforge" target="_blank">ChartForge</a>
+    </p>
+  </div>
+</body>
+</html>`;
+}
+function buildStats(data) {
+  const allVals = data.series.flatMap((s) => s.data).filter((v) => isFinite(v));
+  if (!allVals.length) return [];
+  const sum = allVals.reduce((s, v) => s + v, 0);
+  const avg = sum / allVals.length;
+  const fmt = (v) => {
+    if (Math.abs(v) >= 1e6) return `${(v / 1e6).toFixed(2)}M`;
+    if (Math.abs(v) >= 1e3) return `${(v / 1e3).toFixed(1)}k`;
+    return Number.isInteger(v) ? String(v) : v.toFixed(2);
+  };
+  return [
+    { label: "Data Points", value: String(allVals.length) },
+    { label: "Series", value: String(data.series.length) },
+    { label: "Maximum", value: fmt(Math.max(...allVals)) },
+    { label: "Minimum", value: fmt(Math.min(...allVals)) },
+    { label: "Average", value: fmt(avg) },
+    { label: "Total / Sum", value: fmt(sum) }
+  ];
+}
+function escHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function writeOutput(content, outPath) {
+  const abs = path.resolve(outPath);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content);
+  index.logger.success(`Saved → ${abs}`);
+}
+function writeStdout(content) {
+  process.stdout.write(content);
+}
+function defaultFilename(format) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  return `chartforge-${ts}.${format}`;
+}
+async function openInBrowser(filePath) {
+  const abs = path.resolve(filePath);
+  const open = await import("open").catch(() => null);
+  if (open) {
+    await open.default(`file://${abs}`);
+  } else {
+    index.logger.info(`Open in browser: file://${abs}`);
+  }
+}
+exports.defaultFilename = defaultFilename;
+exports.fetchData = fetchData;
+exports.generateHTML = generateHTML;
+exports.openInBrowser = openInBrowser;
+exports.parseInput = parseInput;
+exports.parseJSON = parseJSON;
+exports.pollData = pollData;
+exports.renderToSVG = renderToSVG;
+exports.renderToTerminal = renderToTerminal;
+exports.writeOutput = writeOutput;
+exports.writeStdout = writeStdout;