@classic-homes/charts-core 0.2.0 → 0.3.1

package/dist/index.cjs

@@ -284,7 +284,12 @@ var lightChartColors = {
   axisPointerLabel: themeTokens.semanticColors.light.mutedForeground,
   divider: themeTokens.colors.gray[600],
   success: themeTokens.semanticColors.light.success,
-  destructive: themeTokens.semanticColors.light.destructive
+  destructive: themeTokens.semanticColors.light.destructive,
+  warning: themeTokens.semanticColors.light.warning,
+  reference: themeTokens.semanticColors.light.mutedForeground,
+  referenceBand: "rgba(102, 102, 102, 0.08)",
+  surface: themeTokens.semanticColors.light.card,
+  ranges: [themeTokens.colors.gray[300], themeTokens.colors.gray[200], themeTokens.colors.gray[100]]
 };
 var darkChartColors = {
   series: darkTheme.color,
@@ -294,7 +299,12 @@ var darkChartColors = {
   axisPointerLabel: themeTokens.colors.gray[600],
   divider: themeTokens.colors.gray[700],
   success: themeTokens.semanticColors.dark.success,
-  destructive: themeTokens.semanticColors.dark.destructive
+  destructive: themeTokens.semanticColors.dark.destructive,
+  warning: themeTokens.semanticColors.dark.warning,
+  reference: themeTokens.semanticColors.dark.mutedForeground,
+  referenceBand: "rgba(255, 255, 255, 0.06)",
+  surface: themeTokens.semanticColors.dark.card,
+  ranges: [themeTokens.colors.gray[600], themeTokens.colors.gray[700], themeTokens.colors.gray[800]]
 };
 function getChartColors(themeName) {
   return themeName === THEME_DARK ? darkChartColors : lightChartColors;
@@ -312,17 +322,58 @@ function colorWithAlpha(color, alpha) {
 }
 
 // src/utils/format.ts
-function formatNumber(value, options) {
-  return new Intl.NumberFormat("en-US", options).format(value);
+var numberFormats = /* @__PURE__ */ new Map();
+function numberFormat(locale, options) {
+  const key = `${locale}|${options ? JSON.stringify(options) : ""}`;
+  let format = numberFormats.get(key);
+  if (!format) {
+    format = new Intl.NumberFormat(locale, options);
+    numberFormats.set(key, format);
+  }
+  return format;
+}
+function formatNumber(value, options, locale = "en-US") {
+  return numberFormat(locale, options).format(value);
+}
+var PRESETS = {
+  number: { maximumFractionDigits: 2 },
+  integer: { maximumFractionDigits: 0 },
+  compact: { notation: "compact", maximumFractionDigits: 1 },
+  currency: { style: "currency", currency: "USD", maximumFractionDigits: 0 },
+  currencyCents: { style: "currency", currency: "USD" },
+  percent: { style: "percent", maximumFractionDigits: 1 },
+  percentValue: { style: "percent", maximumFractionDigits: 1 }
+};
+function resolveValueFormatter(format, locale = "en-US") {
+  if (format === void 0) return void 0;
+  if (typeof format === "function") return format;
+  if (format === "days") {
+    return (value) => {
+      const days = Math.round(value);
+      return `${numberFormat(locale).format(days)} ${Math.abs(days) === 1 ? "day" : "days"}`;
+    };
+  }
+  if (format === "percentValue") {
+    const intl2 = numberFormat(locale, PRESETS.percentValue);
+    return (value) => intl2.format(value / 100);
+  }
+  const intl = numberFormat(locale, typeof format === "string" ? PRESETS[format] : format);
+  return (value) => intl.format(value);
+}
+function formatValue(value, formatter, empty = "") {
+  if (value == null) return empty;
+  if (typeof value === "string") return value;
+  if (!Number.isFinite(value)) return empty;
+  return formatter ? formatter(value) : formatNumber(value, { maximumFractionDigits: 2 });
 }
 function formatCurrency(value, currency = "USD", locale = "en-US") {
-  return new Intl.NumberFormat(locale, {
+  return numberFormat(locale, {
     style: "currency",
     currency
   }).format(value);
 }
 function formatPercent(value, decimals = 1, locale = "en-US") {
-  return new Intl.NumberFormat(locale, {
+  return numberFormat(locale, {
     style: "percent",
     minimumFractionDigits: decimals,
     maximumFractionDigits: decimals
@@ -374,52 +425,80 @@ function createTooltipFormatter(options = {}) {
 }
 
 // src/utils/accessibility.ts
-function generateLineChartDescription(title, data) {
+var isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+function seriesList(names) {
+  return names.join(", ");
+}
+function describeTrends(title, kind, data, format) {
   const seriesCount = data.series.length;
-  const categoryCount = data.categories.length;
-  const seriesNames = data.series.map((s) => s.name).join(", ");
-  let description = `${title}. Line chart with ${categoryCount} data points`;
+  let description = `${title}. ${kind} chart with ${data.categories.length} data points`;
   if (seriesCount > 1) {
-    description += ` across ${seriesCount} series: ${seriesNames}`;
+    description += ` across ${seriesCount} series: ${seriesList(data.series.map((s) => s.name))}`;
   }
   data.series.forEach((series) => {
-    if (series.data.length >= 2) {
-      const first = series.data[0];
-      const last = series.data[series.data.length - 1];
+    const present = series.data.filter(isNumber);
+    if (present.length >= 2) {
+      const first = present[0];
+      const last = present[present.length - 1];
       const trend = last > first ? "increasing" : last < first ? "decreasing" : "stable";
-      description += `. ${series.name} shows ${trend} trend from ${first} to ${last}`;
+      description += `. ${series.name} shows ${trend} trend from ${formatValue(first, format)} to ${formatValue(last, format)}`;
     }
   });
+  const missing = data.series.reduce(
+    (sum, series) => sum + series.data.filter((value) => !isNumber(value)).length,
+    0
+  );
+  if (missing > 0) description += `. ${missing} values are missing`;
   return description;
 }
-function generateBarChartDescription(title, data) {
+function generateLineChartDescription(title, data, format) {
+  return describeTrends(title, "Line", data, format);
+}
+function generateAreaChartDescription(title, data, format) {
+  return describeTrends(title, "Area", data, format);
+}
+function generateComboChartDescription(title, data, format) {
+  return describeTrends(title, "Combined bar and line", data, format);
+}
+function extremes(data) {
+  let max;
+  let min;
+  data.series.forEach((series) => {
+    series.data.forEach((value, index) => {
+      if (!isNumber(value)) return;
+      const category = data.categories[index] ?? "";
+      if (!max || value > max.value) max = { value, category };
+      if (!min || value < min.value) min = { value, category };
+    });
+  });
+  return { max, min };
+}
+function generateBarChartDescription(title, data, format) {
   const categoryCount = data.categories.length;
   const seriesCount = data.series.length;
   let description = `${title}. Bar chart with ${categoryCount} categories`;
   if (seriesCount > 1) {
     description += ` and ${seriesCount} series`;
   }
-  let maxValue = -Infinity;
-  let maxCategory = "";
-  let minValue = Infinity;
-  let minCategory = "";
-  data.series.forEach((series) => {
-    series.data.forEach((value, index) => {
-      if (value > maxValue) {
-        maxValue = value;
-        maxCategory = data.categories[index];
-      }
-      if (value < minValue) {
-        minValue = value;
-        minCategory = data.categories[index];
-      }
-    });
-  });
-  description += `. Highest value is ${maxValue} for ${maxCategory}. Lowest value is ${minValue} for ${minCategory}`;
+  const { max, min } = extremes(data);
+  if (max && min) {
+    description += `. Highest value is ${formatValue(max.value, format)} for ${max.category}. Lowest value is ${formatValue(min.value, format)} for ${min.category}`;
+  }
+  return description;
+}
+function generateDotPlotDescription(title, data, format) {
+  let description = `${title}. Dot plot with ${data.categories.length} rows`;
+  if (data.series.length > 1) {
+    description += ` comparing ${seriesList(data.series.map((s) => s.name))}`;
+  }
+  const { max, min } = extremes(data);
+  if (max && min) {
+    description += `. Highest value is ${formatValue(max.value, format)} for ${max.category}. Lowest value is ${formatValue(min.value, format)} for ${min.category}`;
+  }
   return description;
 }
 function generatePieChartDescription(title, data, isDonut = false) {
-  const total = data.reduce((sum, slice) => sum + slice.value, 0);
+  const total = data.reduce((sum, slice) => sum + (isNumber(slice.value) ? slice.value : 0), 0);
   const chartType = isDonut ? "Donut" : "Pie";
   let description = `${title}. ${chartType} chart with ${data.length} segments`;
   if (total === 0) {
@@ -444,6 +523,44 @@ function generateScatterChartDescription(title, data) {
   }
   return description;
 }
+function generateHistogramDescription(title, buckets, total) {
+  let description = `${title}. Histogram of ${total} values in ${buckets.length} buckets`;
+  const peak = buckets.reduce(
+    (best, bucket) => !best || bucket.count > best.count ? bucket : best,
+    void 0
+  );
+  if (peak && peak.count > 0) {
+    description += `. The most common range is ${peak.label} with ${peak.count} values`;
+  }
+  return description;
+}
+function generateBoxPlotDescription(title, groups, format) {
+  let description = `${title}. Box plot of ${groups.length} groups`;
+  const parts = groups.filter((group) => group.stats).slice(0, 5).map(
+    ({ name, stats }) => `${name}: median ${formatValue(stats.median, format)}, middle half ${formatValue(stats.q1, format)} to ${formatValue(stats.q3, format)}`
+  );
+  if (parts.length) description += `. ${parts.join("; ")}`;
+  return description;
+}
+function generateWaterfallDescription(title, steps, final, format) {
+  const changes = steps.filter((step) => !step.isTotal);
+  const increases = changes.filter((step) => step.value > 0).length;
+  const decreases = changes.filter((step) => step.value < 0).length;
+  return `${title}. Waterfall chart with ${steps.length} steps: ${increases} increases and ${decreases} decreases, ending at ${formatValue(final, format)}`;
+}
+function generateBulletDescription(title, items, format) {
+  const withTarget = items.filter((item) => isNumber(item.target));
+  let description = `${title}. Bullet chart with ${items.length} rows`;
+  if (withTarget.length) {
+    const met = withTarget.filter((item) => item.value >= item.target).length;
+    description += `. ${met} of ${withTarget.length} meet their target`;
+  }
+  const parts = items.slice(0, 5).map(
+    (item) => `${item.name} ${formatValue(item.value, format)}${isNumber(item.target) ? ` of ${formatValue(item.target, format)}` : ""}`
+  );
+  if (parts.length) description += `. ${parts.join(", ")}`;
+  return description;
+}
 function generateDataTable(headers, rows) {
   const headerRow = headers.map((h) => `<th scope="col">${escapeHtml(h)}</th>`).join("");
   const bodyRows = rows.map((row) => `<tr>${row.map((cell) => `<td>${escapeHtml(cell)}</td>`).join("")}</tr>`).join("");
@@ -603,7 +720,14 @@ function getLegendItems(names, palette, overrides, visible) {
 function buildAxis(base, config) {
   if (!config) return base;
   const axis = { ...base };
-  const { show, name, nameLocation, nameGap, formatter, rotate, min, max, interval } = config;
+  const { type, show, name, nameLocation, nameGap, formatter, rotate, min, max, interval } = config;
+  if (type !== void 0) {
+    axis.type = type;
+    if (type !== "category") {
+      delete axis.data;
+      delete axis.boundaryGap;
+    }
+  }
   if (show !== void 0) axis.show = show;
   if (name !== void 0) {
     axis.name = name;
@@ -676,43 +800,794 @@ function formatTooltipValue(value, valueFormatter) {
   if (valueFormatter && typeof value === "number") return valueFormatter(value);
   return String(value ?? "");
 }
+function valueLabelFormatter(format) {
+  return (params) => {
+    if (params.label != null && params.label !== "") return params.label;
+    const value = Array.isArray(params.value) ? params.value[params.value.length - 1] : params.value;
+    return formatValue(value, format);
+  };
+}
+function valueAxisConfig(config, format) {
+  if (!format || config?.formatter !== void 0) return config;
+  return { ...config, formatter: (value) => format(Number(value)) };
+}
+function chartFormatters({
+  valueFormat,
+  locale,
+  tooltipValueFormatter,
+  labelFormatter
+}) {
+  const format = resolveValueFormatter(valueFormat, locale);
+  return {
+    format,
+    tooltip: tooltipValueFormatter ?? format,
+    label: labelFormatter ?? (format ? valueLabelFormatter(format) : void 0),
+    axis: (config) => valueAxisConfig(config, format)
+  };
+}
+var STATISTICS = ["average", "median", "min", "max"];
+function buildMarkLine(lines, { valueAxis, format, color, inverse = false }) {
+  if (!lines?.length) return void 0;
+  return {
+    silent: true,
+    symbol: "none",
+    animation: false,
+    data: lines.map((line) => {
+      const statistic = STATISTICS.includes(line.value);
+      const lineColor = line.color ?? color;
+      const position = valueAxis === "y" ? "insideEndTop" : inverse ? "start" : "end";
+      return {
+        ...statistic ? { type: line.value, valueDim: valueAxis } : { [valueAxis === "y" ? "yAxis" : "xAxis"]: line.value },
+        name: line.label,
+        lineStyle: { type: line.style ?? "dashed", color: lineColor, width: 1.5 },
+        label: {
+          show: true,
+          position,
+          color: lineColor,
+          formatter: (params) => line.label ?? formatValue(Number(params.value), format)
+        }
+      };
+    })
+  };
+}
+function buildMarkArea(bands, { valueAxis, bandColor }) {
+  if (!bands?.length) return void 0;
+  const key = valueAxis === "y" ? "yAxis" : "xAxis";
+  return {
+    silent: true,
+    animation: false,
+    data: bands.map((band) => [
+      {
+        [key]: band.from,
+        name: band.label,
+        itemStyle: { color: band.color ?? bandColor },
+        label: {
+          show: !!band.label,
+          position: "insideTopLeft"
+        }
+      },
+      { [key]: band.to }
+    ])
+  };
+}
+function withReferenceMarks(series, lines, bands, options) {
+  if (!lines?.length && !bands?.length) return series;
+  const indexOf = (name) => {
+    if (name === void 0) return 0;
+    const index = series.findIndex((s) => s.name === name);
+    return index === -1 ? 0 : index;
+  };
+  return series.map((s, index) => {
+    const markLine = buildMarkLine(
+      lines?.filter((line) => indexOf(line.series) === index),
+      options
+    );
+    const markArea = buildMarkArea(
+      bands?.filter((band) => indexOf(band.series) === index),
+      options
+    );
+    if (!markLine && !markArea) return s;
+    return { ...s, ...markLine && { markLine }, ...markArea && { markArea } };
+  });
+}
+function buildDataZoom(mode, axis, bottomOffset = 0) {
+  if (!mode) return void 0;
+  const target = axis === "x" ? { xAxisIndex: 0 } : { yAxisIndex: 0 };
+  const zooms = [];
+  if (mode === true || mode === "inside") zooms.push({ type: "inside", ...target });
+  if (mode === true || mode === "slider") {
+    zooms.push(
+      axis === "x" ? { type: "slider", ...target, bottom: 8 + bottomOffset, height: 20 } : { type: "slider", ...target, right: 8, width: 20 }
+    );
+  }
+  return zooms;
+}
+function withZoomInset(inset, mode, axis) {
+  if (mode !== true && mode !== "slider") return inset;
+  const edge = axis === "x" ? "bottom" : "right";
+  const current = typeof inset?.[edge] === "number" ? inset[edge] : 12;
+  return { ...inset, [edge]: current + 36 };
+}
+
+// src/utils/stats.ts
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var clean = (value) => Number(value.toPrecision(12));
+function niceStep(rough) {
+  if (!(rough > 0) || !Number.isFinite(rough)) return 1;
+  const power = 10 ** Math.floor(Math.log10(rough));
+  const fraction = rough / power;
+  const nice = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 2.5 ? 2.5 : fraction <= 5 ? 5 : 10;
+  return clean(nice * power);
+}
+function bucketLabel(start, end, format) {
+  const text = (value) => formatValue(value, format);
+  if (start === -Infinity && end === Infinity) return "All";
+  if (start === -Infinity) return `< ${text(end)}`;
+  if (end === Infinity) return `${text(start)}+`;
+  return `${text(start)}\u2013${text(end)}`;
+}
+function binValues(values, options = {}) {
+  const { bins, binWidth, format } = options;
+  const finite = values.filter(isFiniteNumber);
+  let edges;
+  if (Array.isArray(bins)) {
+    edges = bins.map((bin) => ({
+      start: bin.start ?? -Infinity,
+      end: bin.end ?? Infinity,
+      label: bin.label
+    }));
+  } else {
+    if (!finite.length) return [];
+    let min = Infinity;
+    let max = -Infinity;
+    for (const value of finite) {
+      if (value < min) min = value;
+      if (value > max) max = value;
+    }
+    if (min === max) {
+      edges = [{ start: min, end: max }];
+    } else {
+      let step;
+      let start;
+      if (binWidth && binWidth > 0) {
+        step = binWidth;
+        start = Math.floor(min / step) * step;
+      } else if (typeof bins === "number" && bins > 0) {
+        step = (max - min) / Math.floor(bins);
+        start = min;
+      } else {
+        const sturges = Math.ceil(Math.log2(finite.length) + 1);
+        step = niceStep((max - min) / sturges);
+        start = Math.floor(min / step) * step;
+      }
+      const count = Math.max(1, Math.ceil(clean((max - start) / step)));
+      edges = Array.from({ length: count }, (_, index) => ({
+        start: clean(start + index * step),
+        end: clean(start + (index + 1) * step)
+      }));
+    }
+  }
+  const buckets = edges.map(({ start, end, label }) => ({
+    label: label ?? bucketLabel(start, end, format),
+    start,
+    end,
+    count: 0
+  }));
+  const last = buckets.length - 1;
+  for (const value of finite) {
+    const index = buckets.findIndex(
+      (bucket, i) => value >= bucket.start && (value < bucket.end || i === last && value <= bucket.end)
+    );
+    if (index !== -1) buckets[index].count++;
+  }
+  return buckets;
+}
+function quantile(sorted, q) {
+  if (!sorted.length) return NaN;
+  const position = (sorted.length - 1) * q;
+  const lower = Math.floor(position);
+  const upper = Math.ceil(position);
+  if (lower === upper) return sorted[lower];
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * (position - lower);
+}
+function boxplotStats(values) {
+  const sorted = values.filter(isFiniteNumber).sort((a, b) => a - b);
+  if (!sorted.length) return null;
+  const q1 = quantile(sorted, 0.25);
+  const median = quantile(sorted, 0.5);
+  const q3 = quantile(sorted, 0.75);
+  const iqr = q3 - q1;
+  const lowFence = q1 - 1.5 * iqr;
+  const highFence = q3 + 1.5 * iqr;
+  const inside = sorted.filter((value) => value >= lowFence && value <= highFence);
+  const outliers = sorted.filter((value) => value < lowFence || value > highFence);
+  return {
+    low: inside[0] ?? q1,
+    q1,
+    median,
+    q3,
+    high: inside[inside.length - 1] ?? q3,
+    outliers,
+    count: sorted.length,
+    mean: sorted.reduce((sum, value) => sum + value, 0) / sorted.length
+  };
+}
+function waterfallLayout(steps) {
+  let running = 0;
+  return steps.map((step) => {
+    let start;
+    let end;
+    let kind;
+    if (step.isTotal === "value") {
+      start = 0;
+      end = isFiniteNumber(step.value) ? step.value : running;
+      kind = "total";
+    } else if (step.isTotal) {
+      start = 0;
+      end = running;
+      kind = "total";
+    } else {
+      const change = isFiniteNumber(step.value) ? step.value : 0;
+      start = running;
+      end = running + change;
+      kind = change < 0 ? "decrease" : "increase";
+    }
+    running = end;
+    const low = Math.min(start, end);
+    const high = Math.max(start, end);
+    let base = 0;
+    let positive = 0;
+    let negative = 0;
+    if (low >= 0) {
+      base = low;
+      positive = high - low;
+    } else if (high <= 0) {
+      base = high;
+      negative = low - high;
+    } else {
+      positive = high;
+      negative = low;
+    }
+    return {
+      start,
+      end,
+      value: kind === "total" ? end : end - start,
+      kind,
+      base: clean(base),
+      positive: clean(positive),
+      negative: clean(negative)
+    };
+  });
+}
+function toPercentStack(series) {
+  const length = Math.max(0, ...series.map((s) => s.data.length));
+  const totals = Array.from(
+    { length },
+    (_, index) => series.reduce((sum, s) => {
+      const value = s.data[index];
+      return sum + (isFiniteNumber(value) ? Math.abs(value) : 0);
+    }, 0)
+  );
+  return series.map((s) => ({
+    ...s,
+    data: s.data.map((value, index) => {
+      if (!isFiniteNumber(value)) return null;
+      return totals[index] === 0 ? 0 : clean(value / totals[index] * 100);
+    })
+  }));
+}
+function pairWithCategories(categories, values, axisType) {
+  if (axisType !== "time" && axisType !== "value") return values;
+  return values.map((value, index) => [categories[index], value]);
+}
+function resolveChartHeight(height, rows, { rowHeight = 28, chrome = 56, minHeight = 160, maxHeight } = {}) {
+  if (height !== "auto") return height;
+  let value = Math.max(minHeight, chrome + Math.max(rows, 1) * rowHeight);
+  if (maxHeight !== void 0) value = Math.min(value, maxHeight);
+  return value;
+}
+function allSeriesEmpty(series) {
+  return !series?.length || series.every((s) => !s.data?.some((value) => value != null));
+}
+function trendLine(points) {
+  const finite = points.filter(([x, y]) => isFiniteNumber(x) && isFiniteNumber(y));
+  const n = finite.length;
+  if (n < 2) return null;
+  let sumX = 0;
+  let sumY = 0;
+  let sumXY = 0;
+  let sumX2 = 0;
+  let minX = Infinity;
+  let maxX = -Infinity;
+  for (const [x, y] of finite) {
+    sumX += x;
+    sumY += y;
+    sumXY += x * y;
+    sumX2 += x * x;
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+  }
+  const denominator = n * sumX2 - sumX * sumX;
+  if (minX === maxX || denominator === 0) return null;
+  const slope = (n * sumXY - sumX * sumY) / denominator;
+  const intercept = (sumY - slope * sumX) / n;
+  return [
+    [minX, slope * minX + intercept],
+    [maxX, slope * maxX + intercept]
+  ];
+}
+function computeDelta(current, previous) {
+  if (!isFiniteNumber(current) || !isFiniteNumber(previous)) return null;
+  const change = clean(current - previous);
+  return {
+    change,
+    ratio: previous === 0 ? null : change / Math.abs(previous),
+    direction: change > 0 ? "up" : change < 0 ? "down" : "flat"
+  };
+}
+
+// src/utils/records.ts
+function read(row, accessor) {
+  return typeof accessor === "function" ? accessor(row) : row[accessor];
+}
+function toNumber(value) {
+  if (value == null || value === "") return null;
+  const number = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+function toLabel(value, nullLabel) {
+  return value == null || value === "" ? nullLabel : String(value);
+}
+var Cell = class {
+  constructor() {
+    this.sum = 0;
+    this.count = 0;
+    this.min = Infinity;
+    this.max = -Infinity;
+    this.first = null;
+    this.last = null;
+  }
+  add(value) {
+    this.count++;
+    if (value === null) return;
+    this.sum += value;
+    if (value < this.min) this.min = value;
+    if (value > this.max) this.max = value;
+    if (this.first === null) this.first = value;
+    this.last = value;
+  }
+  result(aggregate, present) {
+    switch (aggregate) {
+      case "count":
+        return this.count;
+      case "avg":
+        return present ? this.sum / present : null;
+      case "min":
+        return present ? this.min : null;
+      case "max":
+        return present ? this.max : null;
+      case "first":
+        return this.first;
+      case "last":
+        return this.last;
+      default:
+        return present ? this.sum : null;
+    }
+  }
+};
+var Accumulator = class {
+  constructor() {
+    this.cells = /* @__PURE__ */ new Map();
+  }
+  add(key, value) {
+    let cell = this.cells.get(key);
+    if (!cell) {
+      cell = Object.assign(new Cell(), { present: 0 });
+      this.cells.set(key, cell);
+    }
+    cell.add(value);
+    if (value !== null) cell.present++;
+  }
+  get(key, aggregate) {
+    const cell = this.cells.get(key);
+    return cell ? cell.result(aggregate, cell.present) : null;
+  }
+};
+function ordered(seen, order) {
+  if (!order?.length) return seen;
+  const present = new Set(seen);
+  const first = order.filter((name) => present.has(name));
+  const listed = new Set(first);
+  return [...first, ...seen.filter((name) => !listed.has(name))];
+}
+function fromRecords(rows, options) {
+  const {
+    category,
+    value,
+    series,
+    measures,
+    seriesName = "Value",
+    aggregate = "sum",
+    categoryOrder,
+    topN,
+    otherLabel,
+    seriesOrder,
+    nullLabel = "Unknown",
+    fill = null,
+    colors: colors3
+  } = options;
+  const sort = options.sort ?? (topN !== void 0 ? "total" : "none");
+  const categories = [];
+  const categorySet = /* @__PURE__ */ new Set();
+  const seriesNames = [];
+  const seriesSet = /* @__PURE__ */ new Set();
+  const cells = new Accumulator();
+  const key = (c, s) => `${c}\0${s}`;
+  const note = (list, set, name) => {
+    if (!set.has(name)) {
+      set.add(name);
+      list.push(name);
+    }
+  };
+  for (const row of rows ?? []) {
+    const c = toLabel(read(row, category), nullLabel);
+    note(categories, categorySet, c);
+    if (measures) {
+      for (const [name, accessor] of Object.entries(measures)) {
+        note(seriesNames, seriesSet, name);
+        cells.add(key(c, name), toNumber(read(row, accessor)));
+      }
+    } else {
+      const s = series ? toLabel(read(row, series), nullLabel) : seriesName;
+      note(seriesNames, seriesSet, s);
+      cells.add(key(c, s), value === void 0 ? 1 : toNumber(read(row, value)));
+    }
+  }
+  const names = ordered(seriesNames, seriesOrder);
+  const cellValue = (c, s) => cells.get(key(c, s), aggregate);
+  const total = (c) => names.reduce((sum, s) => sum + (cellValue(c, s) ?? 0), 0);
+  let order = ordered(categories, categoryOrder);
+  if (sort === "total" || sort === "total-asc") {
+    const totals = new Map(order.map((c) => [c, total(c)]));
+    const direction = sort === "total" ? -1 : 1;
+    order = [...order].sort((a, b) => direction * (totals.get(a) - totals.get(b)));
+  } else if (sort === "category") {
+    order = [...order].sort((a, b) => a.localeCompare(b, void 0, { numeric: true }));
+  } else if (typeof sort === "function") {
+    order = [...order].sort(sort);
+  }
+  let rest = [];
+  if (topN !== void 0 && order.length > topN) {
+    rest = order.slice(topN);
+    order = order.slice(0, topN);
+  }
+  const foldOther = otherLabel !== void 0 && rest.length > 0 && (aggregate === "sum" || aggregate === "count");
+  const result = names.map((name) => {
+    const data = order.map((c) => cellValue(c, name) ?? fill);
+    if (foldOther) {
+      const other = rest.reduce((sum, c) => {
+        const v = cellValue(c, name);
+        return v === null ? sum : (sum ?? 0) + v;
+      }, null);
+      data.push(other ?? fill);
+    }
+    return colors3?.[name] ? { name, data, color: colors3[name] } : { name, data };
+  });
+  return {
+    categories: foldOther ? [...order, otherLabel] : order,
+    series: result
+  };
+}
+function toSliceData(rows, options) {
+  const {
+    name,
+    value,
+    aggregate = "sum",
+    dropZero = true,
+    sort = "desc",
+    topN,
+    otherLabel,
+    nullLabel = "Unknown",
+    colors: colors3
+  } = options;
+  const { categories, series } = fromRecords(rows, {
+    category: name,
+    value,
+    aggregate: value === void 0 ? "count" : aggregate,
+    nullLabel
+  });
+  const values = series[0]?.data ?? [];
+  let slices = categories.map((label, index) => ({ name: label, value: values[index] ?? 0 }));
+  if (dropZero) slices = slices.filter((slice) => slice.value !== 0);
+  if (sort !== "none") {
+    const direction = sort === "desc" ? -1 : 1;
+    slices = [...slices].sort((a, b) => direction * (a.value - b.value));
+  }
+  if (topN !== void 0 && slices.length > topN) {
+    const rest = slices.slice(topN);
+    slices = slices.slice(0, topN);
+    if (otherLabel !== void 0) {
+      slices.push({ name: otherLabel, value: rest.reduce((sum, slice) => sum + slice.value, 0) });
+    }
+  }
+  return slices.map(
+    (slice) => colors3?.[slice.name] ? { ...slice, color: colors3[slice.name] } : slice
+  );
+}
+
+// src/utils/tables.ts
+function categoryTable(data, categoryHeader = "Category") {
+  return {
+    headers: [categoryHeader, ...data.series.map((s) => s.name)],
+    rows: data.categories.map((category, index) => [
+      category,
+      ...data.series.map((s) => s.data[index] ?? null)
+    ]),
+    columns: ["text", ...data.series.map(() => "value")]
+  };
+}
+function sliceTable(slices, nameHeader = "Name") {
+  const total = slices.reduce(
+    (sum, slice) => sum + (Number.isFinite(slice.value) ? slice.value : 0),
+    0
+  );
+  return {
+    headers: [nameHeader, "Value", "Share"],
+    rows: slices.map((slice) => [
+      slice.name,
+      slice.value,
+      total ? Number((slice.value / total * 100).toFixed(1)) : 0
+    ]),
+    columns: ["text", "value", "percent"]
+  };
+}
+function scatterTable(data, xHeader = "X", yHeader = "Y") {
+  return {
+    headers: ["Series", xHeader, yHeader],
+    rows: data.series.flatMap((s) => s.data.map(([x, y]) => [s.name, x, y])),
+    columns: ["text", "number", "value"]
+  };
+}
+function radarTable(data, indicators) {
+  return {
+    headers: ["Indicator", ...data.series.map((s) => s.name)],
+    rows: indicators.map((indicator, index) => [
+      indicator.name,
+      ...data.series.map((s) => s.data[index] ?? null)
+    ]),
+    columns: ["text", ...data.series.map(() => "value")]
+  };
+}
+function heatmapTable(data, xAxis, yAxis) {
+  const cells = new Map(data.data.map(([x, y, value]) => [`${x},${y}`, value]));
+  return {
+    headers: ["", ...xAxis],
+    rows: yAxis.map((label, y) => [label, ...xAxis.map((_, x) => cells.get(`${x},${y}`) ?? null)]),
+    columns: ["text", ...xAxis.map(() => "value")]
+  };
+}
+function treemapTable(nodes) {
+  const rows = [];
+  const visit = (list, path) => {
+    for (const node of list) {
+      const nodePath = [...path, node.name];
+      if (node.children?.length) visit(node.children, nodePath);
+      else rows.push([nodePath.join(" / "), node.value ?? null]);
+    }
+  };
+  visit(nodes, []);
+  return { headers: ["Item", "Value"], rows, columns: ["text", "value"] };
+}
+function sankeyTable(data) {
+  return {
+    headers: ["From", "To", "Value"],
+    rows: data.links.map((link) => [link.source, link.target, link.value]),
+    columns: ["text", "text", "value"]
+  };
+}
+function candlestickTable(data) {
+  const withVolume = !!data.volume?.length;
+  return {
+    headers: ["Date", "Open", "High", "Low", "Close", ...withVolume ? ["Volume"] : []],
+    rows: data.data.map((item, index) => [
+      data.dates[index] ?? "",
+      item.open,
+      item.high,
+      item.low,
+      item.close,
+      ...withVolume ? [data.volume?.[index] ?? null] : []
+    ]),
+    columns: [
+      "text",
+      "value",
+      "value",
+      "value",
+      "value",
+      ...withVolume ? ["number"] : []
+    ]
+  };
+}
+function histogramTable(buckets) {
+  return {
+    headers: ["Range", "Count"],
+    rows: buckets.map((bucket) => [bucket.label, bucket.count]),
+    columns: ["text", "number"]
+  };
+}
+function boxPlotTable(groups) {
+  return {
+    headers: ["Group", "Count", "Low", "Q1", "Median", "Q3", "High", "Outliers"],
+    rows: groups.map(
+      ({ name, stats }) => stats ? [
+        name,
+        stats.count,
+        stats.low,
+        stats.q1,
+        stats.median,
+        stats.q3,
+        stats.high,
+        stats.outliers.length
+      ] : [name, 0, null, null, null, null, null, 0]
+    ),
+    columns: ["text", "number", "value", "value", "value", "value", "value", "number"]
+  };
+}
+function waterfallTable(steps, bars) {
+  return {
+    headers: ["Step", "Change", "Total"],
+    rows: steps.map((step, index) => [
+      step.name,
+      bars[index]?.kind === "total" ? null : bars[index]?.value ?? null,
+      bars[index]?.end ?? null
+    ]),
+    columns: ["text", "value", "value"]
+  };
+}
+function bulletTable(items) {
+  const withTarget = items.some((item) => item.target !== void 0);
+  return {
+    headers: ["Name", "Value", ...withTarget ? ["Target"] : []],
+    rows: items.map((item) => [
+      item.name,
+      item.value,
+      ...withTarget ? [item.target ?? null] : []
+    ]),
+    columns: ["text", "value", ...withTarget ? ["value"] : []]
+  };
+}
+function formatTableCell(table, cell, column, format) {
+  if (typeof cell !== "number") return cell ?? "";
+  switch (table.columns?.[column] ?? "value") {
+    case "number":
+      return formatNumber(cell, { maximumFractionDigits: 2 });
+    case "percent":
+      return `${cell}%`;
+    case "text":
+      return String(cell);
+    default:
+      return formatValue(cell, format);
+  }
+}
+function csvCell(cell) {
+  if (cell == null) return "";
+  const text = String(cell);
+  return /[",\r\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+function tableToCsv(table, format) {
+  const lines = [table.headers, ...table.rows].map(
+    (row, rowIndex) => row.map(
+      (cell, column) => csvCell(rowIndex > 0 && format ? formatTableCell(table, cell, column, format) : cell)
+    ).join(",")
+  );
+  return lines.join("\r\n");
+}
+function chartFilename(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "chart";
+}
+function downloadFile(content, filename, mimeType = "text/plain") {
+  if (typeof document === "undefined") return;
+  const isDataUrl = content.startsWith("data:");
+  const url = isDataUrl ? content : URL.createObjectURL(new Blob([content], { type: `${mimeType};charset=utf-8` }));
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  link.style.display = "none";
+  document.body.appendChild(link);
+  link.click();
+  link.remove();
+  if (!isDataUrl) setTimeout(() => URL.revokeObjectURL(url), 0);
+}
+function downloadCsv(table, filename) {
+  downloadFile(
+    `\uFEFF${tableToCsv(table)}`,
+    filename.endsWith(".csv") ? filename : `${filename}.csv`,
+    "text/csv"
+  );
+}
 
 exports.THEME_DARK = THEME_DARK;
 exports.THEME_LIGHT = THEME_LIGHT;
 exports.abbreviateNumber = abbreviateNumber;
+exports.allSeriesEmpty = allSeriesEmpty;
 exports.anchorCenterGraphic = anchorCenterGraphic;
+exports.binValues = binValues;
+exports.boxPlotTable = boxPlotTable;
+exports.boxplotStats = boxplotStats;
 exports.buildAxis = buildAxis;
 exports.buildDataLabel = buildDataLabel;
+exports.buildDataZoom = buildDataZoom;
 exports.buildLegend = buildLegend;
+exports.buildMarkArea = buildMarkArea;
+exports.buildMarkLine = buildMarkLine;
 exports.buildTooltip = buildTooltip;
+exports.bulletTable = bulletTable;
+exports.candlestickTable = candlestickTable;
+exports.categoryTable = categoryTable;
+exports.chartFilename = chartFilename;
+exports.chartFormatters = chartFormatters;
 exports.colorWithAlpha = colorWithAlpha;
+exports.computeDelta = computeDelta;
 exports.createTooltipFormatter = createTooltipFormatter;
 exports.darkChartColors = darkChartColors;
 exports.darkTheme = darkTheme;
+exports.downloadCsv = downloadCsv;
+exports.downloadFile = downloadFile;
 exports.escapeHtml = escapeHtml;
 exports.formatCurrency = formatCurrency;
 exports.formatDate = formatDate;
 exports.formatNumber = formatNumber;
 exports.formatPercent = formatPercent;
+exports.formatTableCell = formatTableCell;
 exports.formatTooltipValue = formatTooltipValue;
+exports.formatValue = formatValue;
+exports.fromRecords = fromRecords;
+exports.generateAreaChartDescription = generateAreaChartDescription;
 exports.generateBarChartDescription = generateBarChartDescription;
+exports.generateBoxPlotDescription = generateBoxPlotDescription;
+exports.generateBulletDescription = generateBulletDescription;
+exports.generateComboChartDescription = generateComboChartDescription;
 exports.generateDarkTheme = generateDarkTheme;
 exports.generateDataTable = generateDataTable;
+exports.generateDotPlotDescription = generateDotPlotDescription;
+exports.generateHistogramDescription = generateHistogramDescription;
 exports.generateLightTheme = generateLightTheme;
 exports.generateLineChartDescription = generateLineChartDescription;
 exports.generatePieChartDescription = generatePieChartDescription;
 exports.generateScatterChartDescription = generateScatterChartDescription;
+exports.generateWaterfallDescription = generateWaterfallDescription;
 exports.getChartColors = getChartColors;
 exports.getLegendItems = getLegendItems;
 exports.getReplaceMerge = getReplaceMerge;
 exports.gridInset = gridInset;
 exports.hasPointLabels = hasPointLabels;
+exports.heatmapTable = heatmapTable;
+exports.histogramTable = histogramTable;
 exports.itemLabelLookup = itemLabelLookup;
 exports.legendCenter = legendCenter;
 exports.lightChartColors = lightChartColors;
 exports.lightTheme = lightTheme;
 exports.mergeChartOption = mergeChartOption;
 exports.nameLabelLookup = nameLabelLookup;
+exports.niceStep = niceStep;
+exports.pairWithCategories = pairWithCategories;
 exports.pointLabel = pointLabel;
+exports.quantile = quantile;
+exports.radarTable = radarTable;
+exports.resolveChartHeight = resolveChartHeight;
+exports.resolveValueFormatter = resolveValueFormatter;
+exports.sankeyTable = sankeyTable;
+exports.scatterTable = scatterTable;
 exports.seriesLabelLookup = seriesLabelLookup;
+exports.sliceTable = sliceTable;
+exports.tableToCsv = tableToCsv;
+exports.toPercentStack = toPercentStack;
+exports.toSliceData = toSliceData;
+exports.treemapTable = treemapTable;
+exports.trendLine = trendLine;
+exports.valueAxisConfig = valueAxisConfig;
+exports.valueLabelFormatter = valueLabelFormatter;
+exports.waterfallLayout = waterfallLayout;
+exports.waterfallTable = waterfallTable;
 exports.withPointLabels = withPointLabels;
+exports.withReferenceMarks = withReferenceMarks;
+exports.withZoomInset = withZoomInset;