@pixerate/editor 0.48.0 → 0.49.0

package/dist/chunk-OV7UAKIY.js

@@ -0,0 +1,674 @@
+// src/chart/color.ts
+var NAMED = {
+  black: "#000000",
+  white: "#ffffff",
+  red: "#ff0000",
+  green: "#008000",
+  blue: "#0000ff",
+  yellow: "#ffff00",
+  orange: "#ffa500",
+  purple: "#800080",
+  gray: "#808080",
+  grey: "#808080",
+  teal: "#008080",
+  navy: "#000080",
+  maroon: "#800000",
+  olive: "#808000",
+  silver: "#c0c0c0",
+  lime: "#00ff00",
+  aqua: "#00ffff",
+  cyan: "#00ffff",
+  fuchsia: "#ff00ff",
+  magenta: "#ff00ff",
+  pink: "#ffc0cb",
+  brown: "#a52a2a"
+};
+function parseChartColor(color) {
+  const text2 = color.trim().toLowerCase();
+  const hex = NAMED[text2] ?? text2;
+  let m = /^#([0-9a-f]{3})$/.exec(hex);
+  if (m) return [...m[1]].map((c) => parseInt(c + c, 16) / 255);
+  m = /^#([0-9a-f]{6})([0-9a-f]{2})?$/.exec(hex);
+  if (m) return [0, 2, 4].map((i) => parseInt(m[1].slice(i, i + 2), 16) / 255);
+  m = /^rgba?\(\s*([\d.]+)%?[\s,]+([\d.]+)%?[\s,]+([\d.]+)%?(?:[\s,/]+[\d.]+%?)?\s*\)$/.exec(text2);
+  if (m) {
+    const pct = text2.includes("%");
+    return [m[1], m[2], m[3]].map((v) => Math.max(0, Math.min(1, Number(v) / (pct ? 100 : 255))));
+  }
+  return null;
+}
+function chartRgbToHex(rgb) {
+  return `#${rgb.map((c) => Math.round(Math.max(0, Math.min(1, c)) * 255).toString(16).padStart(2, "0")).join("")}`;
+}
+function shadeChartColor(color, amount) {
+  const rgb = parseChartColor(color);
+  if (!rgb || !amount) return color;
+  const t = Math.max(-1, Math.min(1, amount));
+  return chartRgbToHex(rgb.map((c) => t > 0 ? c + (1 - c) * t : c * (1 + t)));
+}
+var CHART_PALETTE_SHADES = [0, 0.4, -0.25, 0.6, -0.5, 0.2];
+function cyclePaletteColor(palette, index) {
+  const base = palette[index % palette.length];
+  const round = Math.floor(index / palette.length) % CHART_PALETTE_SHADES.length;
+  return shadeChartColor(base, CHART_PALETTE_SHADES[round]);
+}
+var toLinear = (c) => c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+var fromLinear = (c) => c <= 31308e-7 ? c * 12.92 : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+function chartLuminance(rgb) {
+  const [r, g, b] = rgb.map(toLinear);
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function chartContrastRatio(a, b) {
+  const ra = parseChartColor(a);
+  const rb = parseChartColor(b);
+  if (!ra || !rb) return null;
+  const la = chartLuminance(ra);
+  const lb = chartLuminance(rb);
+  return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+function chartTextOn(fill, fallback, dark = "#0f172a", light = "#ffffff") {
+  const rgb = parseChartColor(fill);
+  if (!rgb) return fallback;
+  const darkRatio = chartContrastRatio(fill, dark);
+  const lightRatio = chartContrastRatio(fill, light);
+  return darkRatio >= lightRatio ? dark : light;
+}
+function chartRgbToOklab(rgb) {
+  const [r, g, b] = rgb.map(toLinear);
+  const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+  const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+  const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+  return [
+    0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
+  ];
+}
+function chartColorDistance(a, b) {
+  const p = chartRgbToOklab(a);
+  const q = chartRgbToOklab(b);
+  return Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);
+}
+var CVD = {
+  protanopia: [
+    [0.152286, 1.052583, -0.204868],
+    [0.114503, 0.786281, 0.099216],
+    [-3882e-6, -0.048116, 1.051998]
+  ],
+  deuteranopia: [
+    [0.367322, 0.860646, -0.227968],
+    [0.280085, 0.672501, 0.047413],
+    [-0.01182, 0.04294, 0.968881]
+  ],
+  tritanopia: [
+    [1.255528, -0.076749, -0.178779],
+    [-0.078411, 0.930809, 0.147602],
+    [4733e-6, 0.691367, 0.3039]
+  ]
+};
+function simulateChartVision(rgb, vision) {
+  if (vision === "normal") return rgb;
+  const lin = rgb.map(toLinear);
+  const m = CVD[vision];
+  return m.map((row) => fromLinear(Math.max(0, Math.min(1, row[0] * lin[0] + row[1] * lin[1] + row[2] * lin[2]))));
+}
+function checkChartColors(colors, options = {}) {
+  const surface = options.surface ?? "#ffffff";
+  const minDistance = options.minDistance ?? 0.08;
+  const minContrast = options.minContrast ?? 1.5;
+  const visions = options.visions ?? ["normal", "protanopia", "deuteranopia", "tritanopia"];
+  const parsed = colors.map(parseChartColor);
+  const skipped = colors.filter((_, i) => !parsed[i]);
+  const issues = [];
+  const closest = {};
+  for (const vision of visions) {
+    const seen = parsed.map((c) => c ? simulateChartVision(c, vision) : null);
+    let best;
+    for (let a = 0; a < seen.length; a++) {
+      for (let b = a + 1; b < seen.length; b++) {
+        if (!seen[a] || !seen[b]) continue;
+        const distance = chartColorDistance(seen[a], seen[b]);
+        if (!best || distance < best.distance) best = { a, b, colors: [colors[a], colors[b]], distance: Math.round(distance * 1e3) / 1e3 };
+      }
+    }
+    if (best) {
+      closest[vision] = best;
+      if (best.distance < minDistance) {
+        const who = vision === "normal" ? "" : ` with ${vision}`;
+        issues.push(`Colours ${best.a + 1} (${best.colors[0]}) and ${best.b + 1} (${best.colors[1]}) are hard to tell apart${who} (distance ${best.distance}, want at least ${minDistance}).`);
+      }
+    }
+  }
+  const contrast = colors.map((c) => {
+    const ratio = chartContrastRatio(c, surface);
+    return ratio === null ? null : Math.round(ratio * 100) / 100;
+  });
+  contrast.forEach((ratio, i) => {
+    if (ratio !== null && ratio < minContrast) issues.push(`Colour ${i + 1} (${colors[i]}) barely stands out from the background ${surface} (contrast ${ratio}:1, want at least ${minContrast}:1).`);
+  });
+  return { ok: issues.length === 0, closest, contrast, issues, skipped };
+}
+
+// src/chart/spec.ts
+var CHART_TYPES = ["bar", "line", "area", "scatter", "bubble", "pie", "donut", "radar", "waterfall", "histogram", "box", "funnel", "treemap"];
+var CHART_MARKERS = ["circle", "square", "diamond", "triangle", "cross", "none"];
+var CHART_TRENDLINE_TYPES = ["linear", "exponential", "logarithmic", "power", "polynomial", "moving-average"];
+var CHART_LABEL_POSITIONS = ["auto", "inside", "outside", "center"];
+var CHART_AXIS_KINDS = ["category", "date"];
+var CHART_SERIES_TYPES = ["bar", "line", "area", "scatter"];
+var CHART_STACKINGS = ["none", "stacked", "percent"];
+var CHART_CURVES = ["linear", "smooth", "step"];
+var CHART_ORIENTATIONS = ["vertical", "horizontal"];
+var CHART_LEGEND_POSITIONS = ["top", "bottom", "left", "right"];
+var CHART_NUMBER_STYLES = ["number", "percent", "currency", "compact"];
+var CHART_TYPE_LABELS = {
+  bar: "Bar",
+  line: "Line",
+  area: "Area",
+  scatter: "Scatter",
+  bubble: "Bubble",
+  pie: "Pie",
+  donut: "Donut",
+  radar: "Radar",
+  waterfall: "Waterfall",
+  histogram: "Histogram",
+  box: "Box plot",
+  funnel: "Funnel",
+  treemap: "Treemap"
+};
+var DEFAULT_CHART_PALETTE = ["#4269d0", "#efb118", "#ff725c", "#6cc5b0", "#3ca951", "#ff8ab7", "#a463f2", "#97bbf5", "#9c6b4e", "#9498a0"];
+var DEFAULT_CHART_THEME = {
+  background: "#ffffff",
+  surface: "#ffffff",
+  text: "#0f172a",
+  mutedText: "#64748b",
+  grid: "#e2e8f0",
+  axis: "#94a3b8",
+  selection: "#2563eb",
+  positive: "#3ca951",
+  negative: "#e5484d",
+  fontFamily: 'system-ui, -apple-system, "Segoe UI", sans-serif',
+  fontSize: 11,
+  titleSize: 15
+};
+var CSS_VARIABLE_CHART_THEME = {
+  ...DEFAULT_CHART_THEME,
+  background: "transparent",
+  surface: "var(--background, #ffffff)",
+  text: "var(--foreground, #0f172a)",
+  mutedText: "var(--muted-foreground, #64748b)",
+  grid: "var(--border, #e2e8f0)",
+  axis: "var(--muted-foreground, #94a3b8)",
+  selection: "var(--primary, #2563eb)",
+  fontFamily: "inherit"
+};
+function isCartesianChart(type) {
+  return type === "bar" || type === "line" || type === "area" || type === "scatter";
+}
+function isXyChart(spec) {
+  if (spec.type === "bubble") return true;
+  return spec.type === "scatter" && spec.series.some((s) => !s.hidden && Array.isArray(s.x) && s.x.some((v) => v !== null));
+}
+function chartFamily(spec) {
+  if (isXyChart(spec)) return "xy";
+  switch (spec.type) {
+    case "pie":
+    case "donut":
+      return "pie";
+    case "radar":
+    case "waterfall":
+    case "histogram":
+    case "box":
+    case "funnel":
+    case "treemap":
+      return spec.type;
+    case "bubble":
+      return "xy";
+    default:
+      return "cartesian";
+  }
+}
+function chartColorsByCategory(type) {
+  return type === "pie" || type === "donut" || type === "funnel" || type === "treemap";
+}
+function defaultChartAxis(value) {
+  return { show: true, title: "", min: null, max: null, step: null, gridlines: value, format: {} };
+}
+function createChartSpec(partial = {}) {
+  return normalizeChartSpec(partial).spec;
+}
+function chartSeriesColor(spec, seriesIndex) {
+  const series = spec.series[seriesIndex];
+  if (series?.color) return series.color;
+  return cyclePaletteColor(spec.palette.length ? spec.palette : DEFAULT_CHART_PALETTE, seriesIndex);
+}
+function chartSliceColor(spec, index) {
+  return cyclePaletteColor(spec.palette.length ? spec.palette : DEFAULT_CHART_PALETTE, index);
+}
+function chartPointColor(spec, seriesIndex, index) {
+  return spec.series[seriesIndex]?.pointColors?.[index] || chartSeriesColor(spec, seriesIndex);
+}
+function chartSeriesType(spec, series) {
+  if (series.type) return series.type;
+  if (spec.type === "bubble") return "scatter";
+  return isCartesianChart(spec.type) ? spec.type : "bar";
+}
+function uniqueChartSeriesId(series, base = "series") {
+  const used = new Set(series.map((s) => s.id));
+  for (let i = series.length + 1; ; i++) {
+    const id = `${base}-${i}`;
+    if (!used.has(id)) return id;
+  }
+}
+function parseChartValue(input) {
+  if (input === null || input === void 0) return null;
+  if (typeof input === "number") return Number.isFinite(input) ? input : void 0;
+  if (typeof input !== "string") return void 0;
+  let text2 = input.trim();
+  if (!text2 || text2 === "-" || text2 === "\u2014") return null;
+  let negative = false;
+  if (/^\(.*\)$/.test(text2)) {
+    negative = true;
+    text2 = text2.slice(1, -1).trim();
+  }
+  const percent = text2.endsWith("%");
+  if (percent) text2 = text2.slice(0, -1).trim();
+  text2 = text2.replace(/^[$€£¥]/, "").replace(/,/g, "").replace(/\s+/g, "");
+  if (!/^[-+]?(\d+\.?\d*|\.\d+)(e[-+]?\d+)?$/i.test(text2)) return void 0;
+  let value = Number(text2);
+  if (percent) value /= 100;
+  if (negative) value = -value;
+  return Number.isFinite(value) ? value : void 0;
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function pick(value, options, fallback, path, issues) {
+  if (value === void 0) return fallback;
+  if (typeof value === "string" && options.includes(value)) return value;
+  issues.push({ path, message: `${path} must be one of ${options.map((o) => `"${o}"`).join(", ")}; got ${JSON.stringify(value)}.` });
+  return fallback;
+}
+function text(value, fallback, path, issues) {
+  if (value === void 0 || value === null) return fallback;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  issues.push({ path, message: `${path} must be text.` });
+  return fallback;
+}
+function flag(value, fallback, path, issues) {
+  if (value === void 0) return fallback;
+  if (typeof value === "boolean") return value;
+  issues.push({ path, message: `${path} must be true or false.` });
+  return fallback;
+}
+function bound(value, path, issues) {
+  if (value === void 0 || value === null || value === "") return null;
+  const n = typeof value === "string" ? Number(value) : value;
+  if (typeof n === "number" && Number.isFinite(n)) return n;
+  issues.push({ path, message: `${path} must be a number or null.` });
+  return null;
+}
+function normalizeFormat(value, path, issues) {
+  if (value === void 0 || value === null) return {};
+  if (!isRecord(value)) {
+    issues.push({ path, message: `${path} must be an object.` });
+    return {};
+  }
+  const out = {};
+  if (value.style !== void 0) out.style = pick(value.style, CHART_NUMBER_STYLES, "number", `${path}.style`, issues);
+  if (value.decimals !== void 0) {
+    const d = Number(value.decimals);
+    if (Number.isInteger(d) && d >= 0 && d <= 10) out.decimals = d;
+    else issues.push({ path: `${path}.decimals`, message: `${path}.decimals must be a whole number from 0 to 10.` });
+  }
+  for (const key2 of ["currency", "prefix", "suffix", "code"]) {
+    if (value[key2] !== void 0) out[key2] = text(value[key2], "", `${path}.${key2}`, issues);
+  }
+  return out;
+}
+function normalizeChartAxis(value, fallback, path, issues = []) {
+  if (value === void 0) return { ...fallback, format: { ...fallback.format } };
+  if (!isRecord(value)) {
+    issues.push({ path, message: `${path} must be an object.` });
+    return { ...fallback, format: { ...fallback.format } };
+  }
+  let min = "min" in value ? bound(value.min, `${path}.min`, issues) : fallback.min;
+  let max = "max" in value ? bound(value.max, `${path}.max`, issues) : fallback.max;
+  if (min !== null && max !== null && min >= max) {
+    issues.push({ path: `${path}.max`, message: `${path}.max (${max}) must be greater than ${path}.min (${min}).` });
+    min = fallback.min;
+    max = fallback.max;
+  }
+  let step = "step" in value ? bound(value.step, `${path}.step`, issues) : fallback.step;
+  if (step !== null && !(step > 0)) {
+    issues.push({ path: `${path}.step`, message: `${path}.step must be greater than 0 (or null for automatic).` });
+    step = fallback.step;
+  }
+  const axis = {
+    show: flag(value.show, fallback.show, `${path}.show`, issues),
+    title: text(value.title, fallback.title, `${path}.title`, issues),
+    min,
+    max,
+    step,
+    gridlines: flag(value.gridlines, fallback.gridlines, `${path}.gridlines`, issues),
+    format: "format" in value ? normalizeFormat(value.format, `${path}.format`, issues) : { ...fallback.format }
+  };
+  const kind = "kind" in value ? value.kind === null ? void 0 : pick(value.kind, CHART_AXIS_KINDS, "category", `${path}.kind`, issues) : fallback.kind;
+  if (kind && kind !== "category") axis.kind = kind;
+  return axis;
+}
+function normalizeLegend(value, issues) {
+  const fallback = { show: true, position: "bottom" };
+  if (value === void 0) return fallback;
+  if (!isRecord(value)) {
+    issues.push({ path: "legend", message: "legend must be an object." });
+    return fallback;
+  }
+  return {
+    show: flag(value.show, fallback.show, "legend.show", issues),
+    position: pick(value.position, CHART_LEGEND_POSITIONS, fallback.position, "legend.position", issues)
+  };
+}
+function normalizeChartValues(value, length, path, issues = []) {
+  if (value === void 0) return length ? Array(length).fill(null) : [];
+  if (!Array.isArray(value)) {
+    issues.push({ path, message: `${path} must be an array of numbers.` });
+    return length ? Array(length).fill(null) : [];
+  }
+  const out = value.map((v, i) => {
+    const parsed = parseChartValue(v);
+    if (parsed === void 0) {
+      issues.push({ path: `${path}[${i}]`, message: `${path}[${i}] is not a number: ${JSON.stringify(v)}.` });
+      return null;
+    }
+    return parsed;
+  });
+  if (length === void 0) return out;
+  if (out.length > length) return out.slice(0, length);
+  while (out.length < length) out.push(null);
+  return out;
+}
+function normalizeSeries(value, length, used, index, issues) {
+  const path = `series[${index}]`;
+  if (!isRecord(value)) {
+    issues.push({ path, message: `${path} must be an object with a name and values.` });
+    return null;
+  }
+  let id = typeof value.id === "string" && value.id.trim() ? value.id.trim() : "";
+  if (!id || used.has(id)) {
+    if (id) issues.push({ path: `${path}.id`, message: `Series id "${id}" is used twice; the second was renamed.` });
+    for (let n = index + 1; ; n++) {
+      id = `series-${n}`;
+      if (!used.has(id)) break;
+    }
+  }
+  used.add(id);
+  const series = {
+    id,
+    name: text(value.name, `Series ${index + 1}`, `${path}.name`, issues),
+    values: normalizeChartValues(value.values, length, `${path}.values`, issues)
+  };
+  if (typeof value.color === "string" && value.color.trim()) series.color = value.color.trim();
+  if (value.type !== void 0 && value.type !== null) series.type = pick(value.type, CHART_SERIES_TYPES, "bar", `${path}.type`, issues);
+  if (value.hidden === true) series.hidden = true;
+  if (value.axis !== void 0 && value.axis !== null && pick(value.axis, ["primary", "secondary"], "primary", `${path}.axis`, issues) === "secondary") series.axis = "secondary";
+  for (const key2 of ["x", "sizes"]) {
+    if (value[key2] === void 0 || value[key2] === null) continue;
+    const list = normalizeChartValues(value[key2], length, `${path}.${key2}`, issues);
+    if (list.some((v) => v !== null)) series[key2] = list;
+  }
+  if (key(value, "sizes") && series.sizes?.some((v) => v !== null && v < 0)) {
+    issues.push({ path: `${path}.sizes`, message: `${path}.sizes must not be negative.` });
+    series.sizes = series.sizes.map((v) => v !== null && v < 0 ? null : v);
+  }
+  if (value.pointColors !== void 0 && value.pointColors !== null) {
+    if (!Array.isArray(value.pointColors)) issues.push({ path: `${path}.pointColors`, message: `${path}.pointColors must be an array of colours or nulls.` });
+    else {
+      const colors = Array.from({ length }, (_, i) => {
+        const c = value.pointColors[i];
+        return typeof c === "string" && c.trim() ? c.trim() : null;
+      });
+      if (colors.some((c) => c !== null)) series.pointColors = colors;
+    }
+  }
+  if (value.marker !== void 0 && value.marker !== null) series.marker = pick(value.marker, CHART_MARKERS, "circle", `${path}.marker`, issues);
+  if (value.curve !== void 0 && value.curve !== null) series.curve = pick(value.curve, CHART_CURVES, "linear", `${path}.curve`, issues);
+  if (value.dataLabels !== void 0 && value.dataLabels !== null) series.dataLabels = flag(value.dataLabels, false, `${path}.dataLabels`, issues);
+  if (value.format !== void 0 && value.format !== null) {
+    const format = normalizeFormat(value.format, `${path}.format`, issues);
+    if (Object.keys(format).length) series.format = format;
+  }
+  if (value.trendlines !== void 0 && value.trendlines !== null) {
+    if (!Array.isArray(value.trendlines)) issues.push({ path: `${path}.trendlines`, message: `${path}.trendlines must be an array.` });
+    else {
+      const lines = value.trendlines.map((t, i) => normalizeChartTrendline(t, `${path}.trendlines[${i}]`, issues)).filter((t) => t !== null);
+      if (lines.length) series.trendlines = lines;
+    }
+  }
+  return series;
+}
+var key = (value, name) => value[name] !== void 0 && value[name] !== null;
+function normalizeChartTrendline(value, path, issues = []) {
+  if (!isRecord(value)) {
+    issues.push({ path, message: `${path} must be an object with a type.` });
+    return null;
+  }
+  const type = pick(value.type, CHART_TRENDLINE_TYPES, "linear", `${path}.type`, issues);
+  const line = { type };
+  const whole = (name, min, max) => {
+    if (!key(value, name)) return;
+    const n = Number(value[name]);
+    if (Number.isInteger(n) && n >= min && n <= max) line[name] = n;
+    else issues.push({ path: `${path}.${name}`, message: `${path}.${name} must be a whole number from ${min} to ${max}.` });
+  };
+  if (type === "polynomial") whole("order", 2, 6);
+  if (type === "moving-average") whole("period", 2, 1e3);
+  for (const name of ["forward", "backward"]) {
+    if (!key(value, name)) continue;
+    const n = Number(value[name]);
+    if (Number.isFinite(n) && n >= 0) {
+      if (n > 0) line[name] = n;
+    } else issues.push({ path: `${path}.${name}`, message: `${path}.${name} must be a number of x units, 0 or more.` });
+  }
+  if (key(value, "intercept")) {
+    const n = Number(value.intercept);
+    if (!Number.isFinite(n)) issues.push({ path: `${path}.intercept`, message: `${path}.intercept must be a number or null.` });
+    else if (type === "linear" || type === "polynomial" || type === "exponential") {
+      if (type === "exponential" && n <= 0) issues.push({ path: `${path}.intercept`, message: `${path}.intercept must be greater than 0 for an exponential trendline.` });
+      else line.intercept = n;
+    } else issues.push({ path: `${path}.intercept`, message: `A ${type} trendline cannot have a fixed intercept; use linear, polynomial or exponential.` });
+  }
+  for (const name of ["showEquation", "showR2"]) if (key(value, name) && flag(value[name], false, `${path}.${name}`, issues)) line[name] = true;
+  for (const name of ["name", "color"]) {
+    if (!key(value, name)) continue;
+    const t = text(value[name], "", `${path}.${name}`, issues).trim();
+    if (t) line[name] = t;
+  }
+  return line;
+}
+function normalizeChartSpec(input) {
+  const issues = [];
+  const value = isRecord(input) ? input : {};
+  if (input !== void 0 && !isRecord(input)) issues.push({ path: "", message: "A chart must be an object." });
+  const type = pick(value.type, CHART_TYPES, "bar", "type", issues);
+  const rawSeries = Array.isArray(value.series) ? value.series : [];
+  if (value.series !== void 0 && !Array.isArray(value.series)) issues.push({ path: "series", message: "series must be an array." });
+  let categories;
+  if (Array.isArray(value.categories)) categories = value.categories.map((c, i) => text(c, "", `categories[${i}]`, issues));
+  else {
+    if (value.categories !== void 0) issues.push({ path: "categories", message: "categories must be an array of labels." });
+    const longest = rawSeries.reduce((n, s) => Math.max(n, isRecord(s) && Array.isArray(s.values) ? s.values.length : 0), 0);
+    categories = Array.from({ length: longest }, (_, i) => `${i + 1}`);
+  }
+  const used = /* @__PURE__ */ new Set();
+  const series = rawSeries.map((s, i) => normalizeSeries(s, categories.length, used, i, issues)).filter((s) => s !== null);
+  let palette = [...DEFAULT_CHART_PALETTE];
+  if (Array.isArray(value.palette)) {
+    const colors = value.palette.filter((c) => typeof c === "string" && c.trim() !== "");
+    if (colors.length) palette = colors;
+    else issues.push({ path: "palette", message: "palette must list at least one colour." });
+  } else if (value.palette !== void 0) issues.push({ path: "palette", message: "palette must be an array of colours." });
+  const fraction = (name, fallback, min, max) => {
+    if (value[name] === void 0) return fallback;
+    const r = Number(value[name]);
+    if (value[name] !== null && Number.isFinite(r) && r >= min && r <= max) return r;
+    issues.push({ path: name, message: `${name} must be a number from ${min} to ${max}.` });
+    return fallback;
+  };
+  const innerRadius = fraction("innerRadius", 0.55, 0, 0.9);
+  const gapWidth = fraction("gapWidth", 0.28, 0, 0.9);
+  const overlap = fraction("overlap", -0.12, -1, 1);
+  let bins = null;
+  if (value.bins !== void 0 && value.bins !== null) {
+    const b = Number(value.bins);
+    if (Number.isInteger(b) && b >= 1 && b <= 500) bins = b;
+    else issues.push({ path: "bins", message: "bins must be a whole number from 1 to 500, or null for automatic." });
+  }
+  const spec = {
+    version: 1,
+    type,
+    title: text(value.title, "", "title", issues),
+    subtitle: text(value.subtitle, "", "subtitle", issues),
+    categories,
+    series,
+    xAxis: normalizeChartAxis(value.xAxis, defaultChartAxis(false), "xAxis", issues),
+    yAxis: normalizeChartAxis(value.yAxis, defaultChartAxis(true), "yAxis", issues),
+    yAxis2: normalizeChartAxis(value.yAxis2, defaultChartAxis(false), "yAxis2", issues),
+    legend: normalizeLegend(value.legend, issues),
+    stacking: pick(value.stacking, CHART_STACKINGS, "none", "stacking", issues),
+    orientation: pick(value.orientation, CHART_ORIENTATIONS, "vertical", "orientation", issues),
+    curve: pick(value.curve, CHART_CURVES, "linear", "curve", issues),
+    points: flag(value.points, true, "points", issues),
+    dataLabels: flag(value.dataLabels, false, "dataLabels", issues),
+    labelPosition: pick(value.labelPosition, CHART_LABEL_POSITIONS, "auto", "labelPosition", issues),
+    palette,
+    innerRadius,
+    gapWidth,
+    overlap,
+    bins,
+    showTotal: flag(value.showTotal, true, "showTotal", issues)
+  };
+  return { spec, issues };
+}
+function cloneChartSpec(spec) {
+  return {
+    ...spec,
+    categories: [...spec.categories],
+    series: spec.series.map(cloneChartSeries),
+    xAxis: { ...spec.xAxis, format: { ...spec.xAxis.format } },
+    yAxis: { ...spec.yAxis, format: { ...spec.yAxis.format } },
+    yAxis2: { ...spec.yAxis2, format: { ...spec.yAxis2.format } },
+    legend: { ...spec.legend },
+    palette: [...spec.palette]
+  };
+}
+function cloneChartSeries(series) {
+  const copy = { ...series, values: [...series.values] };
+  if (series.x) copy.x = [...series.x];
+  if (series.sizes) copy.sizes = [...series.sizes];
+  if (series.pointColors) copy.pointColors = [...series.pointColors];
+  if (series.format) copy.format = { ...series.format };
+  if (series.trendlines) copy.trendlines = series.trendlines.map((t) => ({ ...t }));
+  return copy;
+}
+function chartDataFromTable(rows, options = {}) {
+  let grid = rows.map((r) => [...r]).filter((r) => r.some((c) => c !== null && c !== void 0 && String(c).trim() !== ""));
+  if (options.seriesIn === "rows") {
+    const width2 = Math.max(0, ...grid.map((r) => r.length));
+    grid = Array.from({ length: width2 }, (_, c) => grid.map((r) => r[c]));
+  }
+  const issues = [];
+  if (!grid.length) return { categories: [], series: [], issues };
+  const width = Math.max(...grid.map((r) => r.length));
+  const header = options.header === "auto" ? grid[0].slice(1).some((c) => c !== null && c !== void 0 && String(c).trim() !== "" && parseChartValue(c) === void 0) : options.header ?? true;
+  const names = header ? grid[0] : [];
+  const body = header ? grid.slice(1) : grid;
+  const categories = body.map((r, i) => {
+    const c = r[0];
+    return c === null || c === void 0 || String(c).trim() === "" ? `${i + 1}` : String(c).trim();
+  });
+  const series = [];
+  for (let col = 1; col < width; col++) {
+    const name = names[col] !== void 0 && String(names[col]).trim() ? String(names[col]).trim() : `Series ${col}`;
+    const values = body.map((r, i) => {
+      const parsed = parseChartValue(r[col] ?? null);
+      if (parsed === void 0) {
+        issues.push({ path: `${name}[${i}]`, message: `"${String(r[col])}" in ${name} (${categories[i]}) is not a number; it was left blank.` });
+        return null;
+      }
+      return parsed;
+    });
+    series.push({ id: `series-${col}`, name, values });
+  }
+  if (options.xFromFirstColumn) {
+    const x = body.map((r, i) => {
+      const parsed = parseChartValue(r[0] ?? null);
+      if (parsed === void 0) issues.push({ path: `x[${i}]`, message: `"${String(r[0])}" in the first column is not a number; that point has no x.` });
+      return parsed ?? null;
+    });
+    for (const s of series) s.x = [...x];
+  }
+  return { categories, series, issues };
+}
+function chartDataToTable(spec, options = {}) {
+  return [
+    [options.categoryHeader ?? "", ...spec.series.map((s) => s.name)],
+    ...spec.categories.map((category, i) => [category, ...spec.series.map((s) => s.values[i] ?? null)])
+  ];
+}
+function chartColorInputValue(color) {
+  if (/^#[0-9a-f]{6}$/i.test(color)) return color.toLowerCase();
+  if (/^#[0-9a-f]{3}$/i.test(color)) return `#${[...color.slice(1)].map((c) => c + c).join("")}`.toLowerCase();
+  return "#000000";
+}
+
+export {
+  parseChartColor,
+  chartRgbToHex,
+  shadeChartColor,
+  CHART_PALETTE_SHADES,
+  cyclePaletteColor,
+  chartLuminance,
+  chartContrastRatio,
+  chartTextOn,
+  chartRgbToOklab,
+  chartColorDistance,
+  simulateChartVision,
+  checkChartColors,
+  CHART_TYPES,
+  CHART_MARKERS,
+  CHART_TRENDLINE_TYPES,
+  CHART_LABEL_POSITIONS,
+  CHART_AXIS_KINDS,
+  CHART_SERIES_TYPES,
+  CHART_STACKINGS,
+  CHART_CURVES,
+  CHART_ORIENTATIONS,
+  CHART_LEGEND_POSITIONS,
+  CHART_NUMBER_STYLES,
+  CHART_TYPE_LABELS,
+  DEFAULT_CHART_PALETTE,
+  DEFAULT_CHART_THEME,
+  CSS_VARIABLE_CHART_THEME,
+  isCartesianChart,
+  isXyChart,
+  chartFamily,
+  chartColorsByCategory,
+  defaultChartAxis,
+  createChartSpec,
+  chartSeriesColor,
+  chartSliceColor,
+  chartPointColor,
+  chartSeriesType,
+  uniqueChartSeriesId,
+  parseChartValue,
+  normalizeChartAxis,
+  normalizeChartValues,
+  normalizeChartTrendline,
+  normalizeChartSpec,
+  cloneChartSpec,
+  cloneChartSeries,
+  chartDataFromTable,
+  chartDataToTable,
+  chartColorInputValue
+};
+//# sourceMappingURL=chunk-OV7UAKIY.js.map