@bonnard/mcp-charts 0.1.3 → 0.2.0

package/dist/chunk-EZYN3JQ4.js

@@ -0,0 +1,706 @@
+import {
+  inferFields,
+  looksLikeLooseDate
+} from "./chunk-IXRGLZX2.js";
+
+// src/resolve/detect.ts
+function detectChartType(fields) {
+  if (fields.some((f) => f.role === "time")) return "line";
+  if (fields.some((f) => f.role === "dimension")) return "bar";
+  return "table";
+}
+
+// src/resolve/pivot.ts
+function pivotData(data, xKey, pivotKey, valueKey) {
+  const seriesKeys = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of data) {
+    const raw = row[pivotKey];
+    const pivotValue = raw == null || raw === "" ? "(No value)" : String(raw);
+    if (!seen.has(pivotValue)) {
+      seen.add(pivotValue);
+      seriesKeys.push(pivotValue);
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  let collapsed = 0;
+  for (const row of data) {
+    const xValue = String(row[xKey] ?? "");
+    const raw = row[pivotKey];
+    const pivotValue = raw == null || raw === "" ? "(No value)" : String(raw);
+    if (!groups.has(xValue)) groups.set(xValue, { [xKey]: row[xKey] });
+    const group = groups.get(xValue);
+    if (Object.hasOwn(group, pivotValue)) {
+      collapsed++;
+      group[pivotValue] = (Number(group[pivotValue]) || 0) + (Number(row[valueKey]) || 0);
+    } else {
+      group[pivotValue] = row[valueKey];
+    }
+  }
+  return { data: Array.from(groups.values()), seriesKeys, collapsed };
+}
+
+// src/resolve/fill-time.ts
+function fillMissingTimeIntervals(data, xKey, measureKeys, granularity) {
+  if (data.length < 2) return data;
+  const entries = [];
+  for (const row of data) {
+    const date = parseUTC(String(row[xKey]));
+    if (date) entries.push({ date });
+  }
+  if (entries.length < 2) return data;
+  entries.sort((a, b) => a.date.getTime() - b.date.getTime());
+  const min = entries[0].date;
+  const max = entries[entries.length - 1].date;
+  const allDates = generateSequence(min, max, granularity);
+  const anchor = new Date(Date.UTC(min.getUTCFullYear(), min.getUTCMonth(), min.getUTCDate()));
+  const key = (d) => dateKey(d, granularity, anchor);
+  const existing = /* @__PURE__ */ new Map();
+  const emitted = /* @__PURE__ */ new Set();
+  for (const row of data) {
+    const date = parseUTC(String(row[xKey]));
+    if (!date) continue;
+    const k = key(date);
+    const list = existing.get(k) ?? [];
+    list.push(row);
+    existing.set(k, list);
+  }
+  const result = [];
+  for (const date of allDates) {
+    const found = existing.get(key(date));
+    if (found) {
+      for (const row of found) {
+        result.push(row);
+        emitted.add(row);
+      }
+    } else {
+      const nullRow = { [xKey]: toISOish(date) };
+      for (const mk of measureKeys) nullRow[mk] = null;
+      result.push(nullRow);
+    }
+  }
+  for (const row of data) if (!emitted.has(row)) result.push(row);
+  return result;
+}
+function parseUTC(str) {
+  let s = str.trim();
+  if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}/.test(s)) s = s.replace(" ", "T");
+  if (/^\d{4}-\d{2}-\d{2}T/.test(s) && !s.endsWith("Z") && !/[+-]\d{2}:\d{2}$/.test(s)) {
+    s += "Z";
+  } else if (/^\d{4}-\d{2}-\d{2}$/.test(s)) {
+    s += "T00:00:00.000Z";
+  }
+  const d = new Date(s);
+  return isNaN(d.getTime()) ? null : d;
+}
+var WEEK_MS = 7 * 864e5;
+function dateKey(d, granularity, anchor) {
+  const y = d.getUTCFullYear();
+  switch (granularity) {
+    case "year":
+      return String(y);
+    case "quarter":
+      return `${y}-Q${Math.floor(d.getUTCMonth() / 3) + 1}`;
+    case "month":
+      return `${y}-${pad(d.getUTCMonth() + 1)}`;
+    case "week":
+      return `W${Math.floor((d.getTime() - anchor.getTime()) / WEEK_MS)}`;
+    default:
+      return `${y}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`;
+  }
+}
+function toISOish(d) {
+  return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}T00:00:00.000`;
+}
+function pad(n) {
+  return n < 10 ? `0${n}` : String(n);
+}
+function generateSequence(start, end, granularity) {
+  const dates = [];
+  const endTime = end.getTime();
+  const MAX_INTERVALS = 1e4;
+  let y = start.getUTCFullYear();
+  let m = start.getUTCMonth();
+  let d = start.getUTCDate();
+  while (dates.length < MAX_INTERVALS) {
+    const current = new Date(Date.UTC(y, m, d));
+    if (current.getTime() > endTime) break;
+    dates.push(current);
+    switch (granularity) {
+      case "day":
+        d += 1;
+        break;
+      case "week":
+        d += 7;
+        break;
+      case "month":
+        m += 1;
+        d = 1;
+        break;
+      case "quarter":
+        m += 3;
+        d = 1;
+        break;
+      case "year":
+        y += 1;
+        break;
+      default:
+        d += 1;
+        break;
+    }
+  }
+  return dates;
+}
+
+// src/resolve/resolve.ts
+var HORIZONTAL_CATEGORY_THRESHOLD = 8;
+var MAX_PIE_SLICES = 8;
+var MIN_PIE_FRACTION = 0.02;
+var MAX_BARS = 30;
+var MAX_SERIES = 12;
+var MAX_POINTS = 2e3;
+var MAX_SCATTER_POINTS = 2e3;
+var FRACTION_MAX = 1.5;
+function isFractionScale(rows, keys) {
+  let max = -Infinity;
+  for (const r of rows) {
+    for (const k of keys) {
+      const v = r[k];
+      if (v == null) continue;
+      const n = Number(v);
+      if (Number.isFinite(n) && Math.abs(n) > max) max = Math.abs(n);
+    }
+  }
+  return max >= 0 && max <= FRACTION_MAX;
+}
+function resolve(data, opts = {}) {
+  const encode = data.encode ?? {};
+  const fields = inferFields(data);
+  const byName = new Map(fields.map((f) => [f.name, f]));
+  const encodeRefs = (v) => v == null ? [] : Array.isArray(v) ? v : [v];
+  const unknownCols = [
+    ...new Set(
+      [
+        encode.x,
+        ...encodeRefs(encode.y),
+        encode.series,
+        ...encodeRefs(encode.y2),
+        ...encodeRefs(encode.line),
+        encode.size
+      ].filter((c) => !!c && !byName.has(c))
+    )
+  ];
+  if (unknownCols.length) {
+    const msg = `Ignored unknown encode column${unknownCols.length > 1 ? "s" : ""} ${unknownCols.map((c) => `"${c}"`).join(", ")}; available: ${fields.map((f) => f.name).join(", ")}.`;
+    if (opts.strict) throw new Error(msg);
+    data.notes = [msg, ...data.notes ?? []];
+  }
+  const isScatter = opts.chartType === "scatter";
+  if (!isScatter && !encode.x && data.rows.length > 1 && fields.length >= 2 && fields.every((f) => f.role === "measure")) {
+    const distinct = (k) => new Set(data.rows.map((r) => r[k])).size;
+    let best = fields[0];
+    for (const f of fields) if (distinct(f.name) < distinct(best.name)) best = f;
+    best.role = "dimension";
+  }
+  const measureNames = new Set(fields.filter((f) => f.role === "measure").map((f) => f.name));
+  let rows = data.rows.map((row) => {
+    const out = { ...row };
+    for (const k of Object.keys(out)) {
+      if (measureNames.has(k) && out[k] != null) {
+        const n = Number(out[k]);
+        if (!Number.isNaN(n)) out[k] = n;
+      }
+    }
+    return out;
+  });
+  if (isScatter) return withNotes(resolveScatter(rows, fields, encode, opts), data.notes);
+  if (opts.chartType === "funnel") return withNotes(resolveFunnel(rows, fields, encode, opts), data.notes);
+  if (opts.chartType === "waterfall") return withNotes(resolveWaterfall(rows, fields, encode, opts), data.notes);
+  const timeField = fields.find((f) => f.role === "time");
+  const dimField = fields.find((f) => f.role === "dimension");
+  const xField = encode.x ? byName.get(encode.x) : timeField ?? dimField;
+  const x = xField?.name ?? "";
+  const y2Names = encode.y2 ? Array.isArray(encode.y2) ? encode.y2 : [encode.y2] : [];
+  const yNames = (encode.y ? (Array.isArray(encode.y) ? encode.y : [encode.y]).filter((n) => byName.has(n)) : fields.filter((f) => f.role === "measure" && f.name !== x).map((f) => f.name)).filter((n) => !y2Names.includes(n));
+  let chartType = !opts.chartType || opts.chartType === "auto" ? detectChartType(fields) : opts.chartType;
+  if (!x && chartType !== "table") chartType = "table";
+  if (chartType === "table") {
+    return {
+      chartType: "table",
+      data: rows,
+      x: "",
+      series: [],
+      legend: false,
+      ...data.notes?.length && { notes: data.notes },
+      ...opts.title && { title: opts.title },
+      columns: fields.map((f) => ({
+        key: f.name,
+        label: f.label ?? f.name,
+        ...f.format && { format: f.format },
+        ...f.format === "percent" && { fraction: isFractionScale(rows, [f.name]) },
+        ...f.currency && { currency: f.currency },
+        ...f.granularity && { granularity: f.granularity }
+      }))
+    };
+  }
+  if (x) {
+    const isBool = xField?.kind === "boolean";
+    let allEmpty = rows.length > 0;
+    for (const row of rows) {
+      const v = row[x];
+      if (v == null || v === "") row[x] = "(No value)";
+      else {
+        allEmpty = false;
+        if (isBool) row[x] = v === true || v === "true" ? "Yes" : "No";
+      }
+    }
+    if (allEmpty) throw new Error(`Column "${x}" is entirely empty \u2014 nothing to put on the x-axis.`);
+  }
+  const pivotDim = encode.series ?? (timeField && dimField && dimField.name !== x && dimField.kind === "string" ? dimField.name : void 0);
+  const notes = [...data.notes ?? []];
+  if (x && xField?.kind === "string" && rows.some((r) => looksLikeLooseDate(r[x]))) {
+    notes.push(
+      `Column "${x}" looks like non-ISO dates; plotted as unordered categories. Return ISO dates (YYYY-MM-DD) for a sorted time axis.`
+    );
+  }
+  let series;
+  let yAxisRight;
+  if (pivotDim && yNames.length === 1) {
+    const result = pivotData(rows, x, pivotDim, yNames[0]);
+    rows = result.data;
+    series = result.seriesKeys.map((key) => ({ key, label: key }));
+    if (result.collapsed > 0)
+      notes.push(
+        `Summed ${result.collapsed} row(s) that shared the same ${x} + ${pivotDim} \u2014 the data looked unaggregated.`
+      );
+    if (y2Names.length > 0)
+      notes.push(
+        `Secondary-axis measure(s) ${y2Names.map((n) => `"${n}"`).join(", ")} were dropped because the chart is split into series by ${pivotDim}.`
+      );
+    if (series.length > MAX_SERIES) {
+      const grand = (key) => rows.reduce((a, r) => a + (Number(r[key]) || 0), 0);
+      const drop = [...series].sort((a, b) => grand(b.key) - grand(a.key)).slice(MAX_SERIES - 1);
+      const dropKeys = new Set(drop.map((s) => s.key));
+      for (const r of rows) {
+        let other = 0;
+        for (const k of dropKeys) {
+          other += Number(r[k]) || 0;
+          delete r[k];
+        }
+        r.Other = other;
+      }
+      series = [...series.filter((s) => !dropKeys.has(s.key)), { key: "Other", label: "Other" }];
+      notes.push(`Grouped ${drop.length} smaller series into "Other".`);
+    }
+  } else {
+    const lineNames = encode.line ? Array.isArray(encode.line) ? encode.line : [encode.line] : [];
+    series = yNames.map((key) => ({
+      key,
+      label: byName.get(key)?.label ?? key,
+      ...lineNames.includes(key) && { type: "line" }
+    }));
+    for (const key of lineNames) {
+      if (yNames.includes(key) || y2Names.includes(key) || !byName.has(key)) continue;
+      series.push({ key, label: byName.get(key)?.label ?? key, type: "line" });
+    }
+    for (const key of y2Names) series.push({ key, label: byName.get(key)?.label ?? key, axis: "right" });
+    if (y2Names.length > 0) {
+      const f = byName.get(y2Names[0]);
+      yAxisRight = {
+        ...f?.label && { label: f.label },
+        ...f?.format && { format: f.format },
+        ...f?.currency && { currency: f.currency }
+      };
+    }
+    if (x && series.length > 0) {
+      const agg = aggregateByX(
+        rows,
+        x,
+        series.map((s) => s.key)
+      );
+      rows = agg.rows;
+      if (agg.collapsed > 0) {
+        notes.push(`Summed ${agg.collapsed} row(s) that shared the same ${x} \u2014 the data looked unaggregated.`);
+        const rateCols = series.filter((s) => byName.get(s.key)?.format === "percent").map((s) => s.key);
+        if (rateCols.length)
+          notes.push(
+            `${rateCols.map((c) => `"${c}"`).join(", ")} looks like a rate; summing rates is usually wrong \u2014 compute SUM(numerator)/SUM(denominator) in SQL instead.`
+          );
+      }
+    }
+  }
+  if (series.length === 0) {
+    const msg = "No measure column to plot - the chart has no data series. Check that value columns contain numbers (not strings), or declare types via fields.";
+    if (opts.strict) throw new Error(msg);
+    notes.push(msg);
+  }
+  if (opts.chartType === "pie" && series.length > 1) {
+    const msg = `A pie needs one category + one measure; got ${series.length} measures - showing them as separate slices, which is usually not what a pie means.`;
+    if (opts.strict) throw new Error(msg);
+    notes.push(msg);
+  }
+  if (opts.chartType === "line" && xField?.kind === "string" && series.length > 0) {
+    const msg = `A line over categorical "${x}" implies an order that may not exist; consider a bar chart.`;
+    if (opts.strict) throw new Error(msg);
+    notes.push(msg);
+  }
+  if (x && chartType !== "pie") rows = sortRowsByX(rows, x, xField);
+  if (xField?.role === "time" && xField.granularity && x) {
+    rows = fillMissingTimeIntervals(
+      rows,
+      x,
+      series.map((s) => s.key),
+      xField.granularity
+    );
+  }
+  if (chartType === "bar" && series.length > 0 && rows.length > MAX_BARS) {
+    const origLen = rows.length;
+    const total = (r) => series.reduce((a, s) => a + (Number(r[s.key]) || 0), 0);
+    const keep = new Set([...rows].sort((a, b) => total(b) - total(a)).slice(0, MAX_BARS));
+    rows = rows.filter((r) => keep.has(r));
+    notes.push(`Showing the top ${rows.length} of ${origLen} categories by value.`);
+  }
+  if ((chartType === "line" || chartType === "area") && rows.length > MAX_POINTS) {
+    const origLen = rows.length;
+    const step = Math.ceil(origLen / MAX_POINTS);
+    const sampled = rows.filter((_, i) => i % step === 0);
+    if (sampled[sampled.length - 1] !== rows[origLen - 1]) sampled.push(rows[origLen - 1]);
+    rows = sampled;
+    notes.push(`Downsampled ${origLen} points to ${rows.length} for display.`);
+  }
+  if ((opts.stacking === "stacked" || opts.stacking === "stacked100") && series.length > 0) {
+    for (const row of rows) for (const s of series) if (row[s.key] == null) row[s.key] = 0;
+  }
+  if (chartType === "pie" && series.length > 0) {
+    const k = series[0].key;
+    if (!rows.some((r) => Number(r[k]) > 0)) {
+      const neg = rows.filter((r) => r[k] != null && Number(r[k]) < 0);
+      rows = neg.map((r) => ({ ...r, [k]: Math.abs(Number(r[k])) }));
+      if (rows.length > 0) notes.push("All values were negative \u2014 showing their magnitudes.");
+    } else {
+      rows = rows.filter((r) => r[k] != null && Number(r[k]) > 0);
+    }
+    rows = rows.sort((a, b) => (Number(b[k]) || 0) - (Number(a[k]) || 0));
+    const total = rows.reduce((sum, r) => sum + (Number(r[k]) || 0), 0);
+    const isSmall = (r, i) => i >= MAX_PIE_SLICES - 1 || total > 0 && (Number(r[k]) || 0) / total < MIN_PIE_FRACTION;
+    const small = rows.filter(isSmall);
+    if (small.length > 1) {
+      const kept = rows.filter((r, i) => !isSmall(r, i));
+      const other = small.reduce((sum, r) => sum + (Number(r[k]) || 0), 0);
+      rows = [...kept, { [x]: "Other", [k]: other }];
+      notes.push(`Grouped ${small.length} small slices into "Other".`);
+    }
+  }
+  const firstMeasure = byName.get(yNames[0] ?? "");
+  const yAxis = {
+    ...series.length === 1 && { label: series[0].label },
+    ...firstMeasure?.format && { format: firstMeasure.format },
+    ...firstMeasure?.format === "percent" && {
+      fraction: isFractionScale(
+        rows,
+        series.filter((s) => s.axis !== "right").map((s) => s.key)
+      )
+    },
+    ...firstMeasure?.currency && { currency: firstMeasure.currency }
+  };
+  if (yAxisRight?.format === "percent") yAxisRight.fraction = isFractionScale(rows, y2Names);
+  const xAxis = {
+    ...xField && { label: xField.label },
+    ...xField?.granularity && { granularity: xField.granularity },
+    // Numeric (non-time) x: signal the renderer to use a linear scale on line/area, so points
+    // sit at their true positions (irregular gaps show) instead of evenly-spaced categories.
+    ...xField?.kind === "number" && { numeric: true }
+  };
+  const hasComboLine = series.some((s) => s.type === "line");
+  let horizontal = opts.horizontal;
+  if (horizontal == null && chartType === "bar" && xField?.kind === "string" && rows.length > HORIZONTAL_CATEGORY_THRESHOLD) {
+    horizontal = true;
+  }
+  if (hasComboLine) horizontal = false;
+  const columns = buildColumns(x, xField, series, byName, rows);
+  const reference = [];
+  if (opts.reference) {
+    const primary = series.find((s) => s.axis !== "right") ?? series[0];
+    if (opts.reference.average && primary) {
+      const vals = rows.map((r) => Number(r[primary.key])).filter((v) => Number.isFinite(v));
+      if (vals.length)
+        reference.push({
+          value: Math.round(vals.reduce((a, b) => a + b, 0) / vals.length * 100) / 100,
+          label: "Avg"
+        });
+    }
+    if (opts.reference.target != null) reference.push({ value: opts.reference.target, label: "Target" });
+  }
+  return {
+    chartType,
+    data: rows,
+    x,
+    series,
+    ...reference.length > 0 && { reference },
+    ...Object.keys(xAxis).length > 0 && { xAxis },
+    ...Object.keys(yAxis).length > 0 && { yAxis },
+    ...yAxisRight && Object.keys(yAxisRight).length > 0 && { yAxisRight },
+    legend: series.length > 1,
+    ...opts.stacking && { stacking: opts.stacking },
+    ...horizontal != null && { horizontal },
+    ...opts.title && { title: opts.title },
+    columns,
+    ...notes.length > 0 && { notes }
+  };
+}
+function withNotes(spec, notes) {
+  return notes?.length ? { ...spec, notes: [...notes, ...spec.notes ?? []] } : spec;
+}
+function resolveScatter(rows, fields, encode, opts) {
+  const byName = new Map(fields.map((f) => [f.name, f]));
+  const measures = fields.filter((f) => f.role === "measure");
+  const yEnc = Array.isArray(encode.y) ? encode.y[0] : encode.y;
+  const x = encode.x ?? measures[0]?.name;
+  const y = yEnc ?? measures.find((m) => m.name !== x)?.name;
+  if (!x || !y) {
+    throw new Error(
+      "A scatter chart needs two numeric columns. Select at least two measures (x and y), e.g. orders and revenue."
+    );
+  }
+  const xField = byName.get(x);
+  const yField = byName.get(y);
+  const isNum = (f) => f?.kind === "number";
+  if (!isNum(xField) || !isNum(yField)) {
+    throw new Error(`A scatter chart needs numeric x and y; "${x}" or "${y}" is not numeric.`);
+  }
+  const size = encode.size && byName.get(encode.size)?.kind === "number" ? encode.size : void 0;
+  const groupField = encode.series ? byName.get(encode.series) : void 0;
+  const groupKey = groupField && groupField.kind !== "number" ? groupField.name : void 0;
+  const pointLabel = fields.find((f) => f.role === "dimension" && f.name !== groupKey)?.name;
+  const scatterNotes = [];
+  if (rows.length > MAX_SCATTER_POINTS) {
+    const origLen = rows.length;
+    const step = Math.ceil(origLen / MAX_SCATTER_POINTS);
+    rows = rows.filter((_, i) => i % step === 0);
+    scatterNotes.push(`Showing a sample of ${rows.length} of ${origLen} points.`);
+  }
+  const colMeta = (k, f = byName.get(k)) => ({
+    key: k,
+    label: f?.label ?? k,
+    ...f?.format && { format: f.format },
+    ...f?.currency && { currency: f.currency }
+  });
+  const xAxis = {
+    ...xField?.label && { label: xField.label },
+    ...xField?.format && { format: xField.format },
+    ...xField?.currency && { currency: xField.currency },
+    numeric: true
+  };
+  const yAxis = {
+    ...yField?.label && { label: yField.label },
+    ...yField?.format && { format: yField.format },
+    ...yField?.currency && { currency: yField.currency }
+  };
+  if (groupKey) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      const g = String(r[groupKey] ?? "(No value)");
+      counts.set(g, (counts.get(g) ?? 0) + 1);
+    }
+    const ordered = [...counts.keys()].sort((a, b) => counts.get(b) - counts.get(a));
+    const capped = ordered.length > MAX_SERIES;
+    const kept = new Set(capped ? ordered.slice(0, MAX_SERIES - 1) : ordered);
+    const groupCols = capped ? [...kept, "Other"] : [...kept];
+    const data = rows.map((r) => {
+      const g = String(r[groupKey] ?? "(No value)");
+      const col = kept.has(g) ? g : "Other";
+      return {
+        [x]: r[x],
+        [col]: r[y],
+        ...size && { [size]: r[size] },
+        ...pointLabel && { [pointLabel]: r[pointLabel] }
+      };
+    });
+    const notes = [
+      ...scatterNotes,
+      ...capped ? [`Grouped ${ordered.length - kept.size} smaller categories into "Other".`] : []
+    ];
+    return {
+      chartType: "scatter",
+      data,
+      x,
+      series: groupCols.map((g) => ({ key: g, label: g })),
+      ...size && { size },
+      ...pointLabel && { pointLabel },
+      xAxis,
+      yAxis,
+      legend: true,
+      ...opts.title && { title: opts.title },
+      ...notes.length && { notes },
+      columns: [
+        colMeta(x),
+        ...groupCols.map((g) => ({
+          key: g,
+          label: g,
+          ...yField?.format && { format: yField.format },
+          ...yField?.currency && { currency: yField.currency }
+        })),
+        ...size ? [colMeta(size)] : [],
+        ...pointLabel ? [colMeta(pointLabel)] : []
+      ]
+    };
+  }
+  const columns = [x, y, ...size ? [size] : [], ...pointLabel ? [pointLabel] : []].map((k) => colMeta(k));
+  return {
+    chartType: "scatter",
+    data: rows,
+    x,
+    series: [{ key: y, label: yField?.label ?? y }],
+    ...size && { size },
+    ...pointLabel && { pointLabel },
+    xAxis,
+    yAxis,
+    legend: false,
+    ...opts.title && { title: opts.title },
+    ...scatterNotes.length && { notes: scatterNotes },
+    columns
+  };
+}
+function resolveFunnel(rows, fields, encode, opts) {
+  const byName = new Map(fields.map((f) => [f.name, f]));
+  const dim = encode.x ?? fields.find((f) => f.role === "dimension")?.name;
+  const yEnc = Array.isArray(encode.y) ? encode.y[0] : encode.y;
+  const value = yEnc ?? fields.find((f) => f.role === "measure")?.name;
+  if (!dim || !value) {
+    throw new Error("A funnel chart needs a stage/label column and a numeric value column (e.g. stage + count).");
+  }
+  const valField = byName.get(value);
+  const positive = rows.filter((r) => (Number(r[value]) || 0) > 0);
+  const data = positive.length > 0 ? positive : rows;
+  const colMeta = (k) => {
+    const f = byName.get(k);
+    return {
+      key: k,
+      label: f?.label ?? k,
+      ...f?.format && { format: f.format },
+      ...f?.currency && { currency: f.currency }
+    };
+  };
+  const notes = [];
+  if (!encode.x && byName.get(dim)?.kind === "number") {
+    const msg = `A funnel needs a stage/label column and one measure; got only measures - using "${dim}" values as stage labels.`;
+    if (opts.strict) throw new Error(msg);
+    notes.push(msg);
+  }
+  return {
+    chartType: "funnel",
+    data,
+    x: dim,
+    series: [{ key: value, label: valField?.label ?? value }],
+    legend: false,
+    ...opts.title && { title: opts.title },
+    columns: [dim, value].map(colMeta),
+    ...notes.length && { notes }
+  };
+}
+var TOTAL_RE = /^\s*(total|subtotal|opening|closing|start|end|net|balance)\b/i;
+function resolveWaterfall(rows, fields, encode, opts) {
+  const byName = new Map(fields.map((f) => [f.name, f]));
+  const dim = encode.x ?? fields.find((f) => f.role === "dimension")?.name;
+  const value = (Array.isArray(encode.y) ? encode.y[0] : encode.y) ?? fields.find((f) => f.role === "measure" && f.name !== dim)?.name;
+  if (!dim || !value) {
+    throw new Error(
+      "A waterfall needs a step label and a numeric value. The value should be the SIGNED change at each step (e.g. -240000 for a loss); mark the start/end rows as totals."
+    );
+  }
+  if (rows.length < 2) {
+    throw new Error("A waterfall needs at least a start total and one change step.");
+  }
+  const markerCol = fields.find(
+    (f) => f.name !== dim && f.name !== value && f.role === "dimension" && rows.some((r) => TOTAL_RE.test(String(r[f.name])))
+  );
+  const totals = markerCol ? rows.filter((r) => TOTAL_RE.test(String(r[markerCol.name]))).map((r) => String(r[dim])) : [String(rows[0][dim]), String(rows[rows.length - 1][dim])];
+  const notes = markerCol ? [] : [
+    "No totals column found, so the first and last rows are treated as the opening and closing totals. Mark a column (e.g. type = total) to change this."
+  ];
+  const valField = byName.get(value);
+  const colMeta = (k) => {
+    const f = byName.get(k);
+    return {
+      key: k,
+      label: f?.label ?? k,
+      ...f?.format && { format: f.format },
+      ...f?.currency && { currency: f.currency }
+    };
+  };
+  return {
+    chartType: "waterfall",
+    data: rows,
+    x: dim,
+    series: [{ key: value, label: valField?.label ?? value }],
+    ...totals.length > 0 && { totals: [...new Set(totals)] },
+    ...notes.length && { notes },
+    yAxis: {
+      ...valField?.label && { label: valField.label },
+      ...valField?.format && { format: valField.format },
+      ...valField?.currency && { currency: valField.currency }
+    },
+    legend: false,
+    ...opts.title && { title: opts.title },
+    columns: [dim, value].map(colMeta)
+  };
+}
+function sortRowsByX(rows, xKey, xField) {
+  if (xField?.role === "time") {
+    const t = (v) => {
+      let s = String(v);
+      if (/^\d{4}-\d{2}-\d{2}$/.test(s)) s += "T00:00:00.000Z";
+      else if (/^\d{4}-\d{2}-\d{2}T/.test(s) && !/[Z+-]\d{0,2}:?\d{0,2}$/.test(s.slice(10))) s += "Z";
+      const ms = new Date(s).getTime();
+      return Number.isNaN(ms) ? Infinity : ms;
+    };
+    return [...rows].sort((a, b) => t(a[xKey]) - t(b[xKey]));
+  }
+  if (xField?.kind === "number") {
+    return [...rows].sort((a, b) => (Number(a[xKey]) || 0) - (Number(b[xKey]) || 0));
+  }
+  return rows;
+}
+function aggregateByX(rows, xKey, measureKeys) {
+  const groups = /* @__PURE__ */ new Map();
+  let collapsed = 0;
+  for (const row of rows) {
+    const key = String(row[xKey]);
+    const existing = groups.get(key);
+    if (!existing) {
+      groups.set(key, { ...row });
+    } else {
+      collapsed++;
+      for (const m of measureKeys) {
+        existing[m] = (Number(existing[m]) || 0) + (Number(row[m]) || 0);
+      }
+    }
+  }
+  return { rows: Array.from(groups.values()), collapsed };
+}
+function buildColumns(x, xField, series, byName, rows) {
+  const cols = [];
+  if (x) {
+    cols.push({
+      key: x,
+      label: xField?.label ?? x,
+      ...xField?.granularity && { granularity: xField.granularity }
+    });
+  }
+  for (const s of series) {
+    const f = byName.get(s.key);
+    cols.push({
+      key: s.key,
+      label: s.label,
+      ...f?.format && { format: f.format },
+      ...f?.format === "percent" && { fraction: isFractionScale(rows, [s.key]) },
+      ...f?.currency && { currency: f.currency }
+    });
+  }
+  return cols;
+}
+
+export {
+  resolve
+};
+//# sourceMappingURL=chunk-EZYN3JQ4.js.map