@pixerate/editor 0.162.1 → 0.163.0

package/dist/{chunk-HLOKB7WW.js → chunk-3NEZJCBY.js}

@@ -224,7 +224,7 @@ function parseChartAmountList(text2) {
 }
 
 // src/chart/spec.ts
-var CHART_TYPES = ["bar", "line", "area", "scatter", "bubble", "pie", "donut", "radar", "waterfall", "histogram", "box", "funnel", "treemap"];
+var CHART_TYPES = ["bar", "line", "area", "scatter", "bubble", "pie", "donut", "radar", "waterfall", "histogram", "box", "funnel", "treemap", "sunburst", "slope", "likert", "parliament"];
 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"];
@@ -234,6 +234,9 @@ var CHART_SERIES_TYPES = ["bar", "line", "area", "scatter"];
 var CHART_STACKINGS = ["none", "stacked", "percent"];
 var CHART_CURVES = ["linear", "smooth", "step"];
 var CHART_RADAR_GRATICULES = ["polygon", "circle"];
+var CHART_LIKERT_NEUTRALS = ["split", "separate"];
+var CHART_LIKERT_SORTS = ["none", "positive", "negative"];
+var CHART_REFERENCE_AXES = ["y", "y2", "x"];
 var CHART_ORIENTATIONS = ["vertical", "horizontal"];
 var CHART_LEGEND_POSITIONS = ["top", "bottom", "left", "right"];
 var CHART_NUMBER_STYLES = ["number", "percent", "currency", "compact"];
@@ -250,7 +253,11 @@ var CHART_TYPE_LABELS = {
   histogram: "Histogram",
   box: "Box plot",
   funnel: "Funnel",
-  treemap: "Treemap"
+  treemap: "Treemap",
+  slope: "Slope",
+  likert: "Likert",
+  parliament: "Parliament",
+  sunburst: "Sunburst"
 };
 var DEFAULT_CHART_PALETTE = ["#4269d0", "#efb118", "#ff725c", "#6cc5b0", "#3ca951", "#ff8ab7", "#a463f2", "#97bbf5", "#9c6b4e", "#9498a0"];
 var DEFAULT_CHART_THEME = {
@@ -297,6 +304,10 @@ function chartFamily(spec) {
     case "box":
     case "funnel":
     case "treemap":
+    case "slope":
+    case "likert":
+    case "parliament":
+    case "sunburst":
       return spec.type;
     case "bubble":
       return "xy";
@@ -305,7 +316,10 @@ function chartFamily(spec) {
   }
 }
 function chartColorsByCategory(type) {
-  return type === "pie" || type === "donut" || type === "funnel" || type === "treemap";
+  return type === "pie" || type === "donut" || type === "funnel" || type === "treemap" || type === "slope" || type === "parliament" || type === "sunburst";
+}
+function chartSpecColorsByCategory(spec) {
+  return chartColorsByCategory(spec.type) || chartVariesColors(spec);
 }
 function defaultChartAxis(value) {
   return { show: true, title: "", min: null, max: null, step: null, gridlines: value, format: {} };
@@ -316,17 +330,37 @@ function createChartSpec(partial = {}) {
 function chartSeriesColor(spec, seriesIndex) {
   const series = spec.series[seriesIndex];
   if (series?.color) return series.color;
+  if (spec.type === "likert") return chartLikertColor(spec.series.length, seriesIndex);
   return cyclePaletteColor(spec.palette.length ? spec.palette : DEFAULT_CHART_PALETTE, seriesIndex);
 }
+var LIKERT_NEGATIVE = [["#e66101"], ["#e66101", "#fdb863"], ["#b35806", "#f1a340", "#fee0b6"], ["#b35806", "#e08214", "#fdb863", "#fee0b6"]];
+var LIKERT_POSITIVE = [["#5e3c99"], ["#b2abd2", "#5e3c99"], ["#d8daeb", "#998ec3", "#542788"], ["#d8daeb", "#b2abd2", "#8073ac", "#542788"]];
+var LIKERT_NEUTRAL = "#d4d4d8";
+function chartLikertColor(count, index) {
+  const side = Math.floor(count / 2);
+  if (count % 2 === 1 && index === side) return LIKERT_NEUTRAL;
+  if (!side) return LIKERT_POSITIVE[0][0];
+  const ramp = (sets) => sets[Math.min(side, sets.length) - 1];
+  const pick2 = (list, k) => list[Math.min(list.length - 1, Math.floor(k * list.length / side))];
+  if (index < side) return pick2(ramp(LIKERT_NEGATIVE), index);
+  return pick2(ramp(LIKERT_POSITIVE), index - (count - side));
+}
 function chartSliceColor(spec, index) {
   return cyclePaletteColor(spec.palette.length ? spec.palette : DEFAULT_CHART_PALETTE, index);
 }
+function chartVariesColors(spec) {
+  return !!spec.varyColors && isCartesianChart(spec.type) && spec.series.filter((s) => !s.hidden).length === 1;
+}
 function chartPointColor(spec, seriesIndex, index) {
-  return spec.series[seriesIndex]?.pointColors?.[index] || chartSeriesColor(spec, seriesIndex);
+  const own = spec.series[seriesIndex]?.pointColors?.[index];
+  if (own) return own;
+  if (spec.type && chartVariesColors(spec)) return chartSliceColor(spec, index);
+  return chartSeriesColor(spec, seriesIndex);
 }
 function chartSeriesType(spec, series) {
   if (series.type) return series.type;
   if (spec.type === "bubble") return "scatter";
+  if (spec.type === "slope") return "line";
   return isCartesianChart(spec.type) ? spec.type : "bar";
 }
 function uniqueChartSeriesId(series, base = "series") {
@@ -524,6 +558,16 @@ function normalizeSeries(value, length, used, index, issues) {
       if (colors.some((c) => c !== null)) series.pointColors = colors;
     }
   }
+  if (value.callouts !== void 0 && value.callouts !== null) {
+    if (!Array.isArray(value.callouts)) issues.push({ path: `${path}.callouts`, message: `${path}.callouts must be an array of labels or nulls, one per category.` });
+    else {
+      const labels = Array.from({ length }, (_, i) => {
+        const c = value.callouts[i];
+        return typeof c === "string" && c.trim() ? c : typeof c === "number" ? String(c) : null;
+      });
+      if (labels.some((c) => c !== null)) series.callouts = labels;
+    }
+  }
   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);
@@ -546,6 +590,49 @@ function normalizeSeries(value, length, used, index, issues) {
   return series;
 }
 var key = (value, name) => value[name] !== void 0 && value[name] !== null;
+function referenceCommon(value, path, issues) {
+  const out = {};
+  const label = text(value.label, "", `${path}.label`, issues);
+  if (label) out.label = label;
+  if (key(value, "axis")) {
+    const axis = pick(value.axis, CHART_REFERENCE_AXES, "y", `${path}.axis`, issues);
+    if (axis !== "y") out.axis = axis;
+  }
+  if (typeof value.color === "string" && value.color.trim()) out.color = value.color.trim();
+  else if (key(value, "color")) issues.push({ path: `${path}.color`, message: `${path}.color must be a CSS colour.` });
+  return out;
+}
+var finiteNumber = (value) => {
+  const n = typeof value === "string" && value.trim() ? Number(value) : value;
+  return typeof n === "number" && Number.isFinite(n) ? n : null;
+};
+function normalizeChartReferenceLine(value, path, issues = []) {
+  if (!isRecord(value)) {
+    issues.push({ path, message: `${path} must be an object with a value, e.g. {"value": 100, "label": "Target"}.` });
+    return null;
+  }
+  const at = finiteNumber(value.value);
+  if (at === null) {
+    issues.push({ path: `${path}.value`, message: `${path}.value must be a number (where the line crosses the axis).` });
+    return null;
+  }
+  for (const k of Object.keys(value)) if (!["value", "label", "axis", "color"].includes(k)) issues.push({ path: `${path}.${k}`, message: `${path} has no "${k}"; it takes value, label, axis and color.` });
+  return { value: at, ...referenceCommon(value, path, issues) };
+}
+function normalizeChartReferenceBand(value, path, issues = []) {
+  if (!isRecord(value)) {
+    issues.push({ path, message: `${path} must be an object with from and to, e.g. {"from": 80, "to": 120, "label": "Target range"}.` });
+    return null;
+  }
+  const from = finiteNumber(value.from);
+  const to = finiteNumber(value.to);
+  if (from === null || to === null) {
+    issues.push({ path, message: `${path} needs numbers for from and to (the ends of the band on its axis).` });
+    return null;
+  }
+  for (const k of Object.keys(value)) if (!["from", "to", "label", "axis", "color"].includes(k)) issues.push({ path: `${path}.${k}`, message: `${path} has no "${k}"; it takes from, to, label, axis and color.` });
+  return { from: Math.min(from, to), to: Math.max(from, to), ...referenceCommon(value, path, issues) };
+}
 function normalizeChartErrorBars(value, length, path, issues = []) {
   if (!isRecord(value)) {
     issues.push({ path, message: `${path} must be an object with a type (${CHART_ERROR_BAR_TYPES.join(", ")}), or null for none.` });
@@ -631,8 +718,14 @@ function normalizeChartSpec(input) {
     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 tree = normalizeChartTree(value.tree, issues);
+  if (tree.length) categories = tree.map((n) => n.name);
   const used = /* @__PURE__ */ new Set();
   const series = rawSeries.map((s, i) => normalizeSeries(s, categories.length, used, i, issues)).filter((s) => s !== null);
+  if (tree.length) {
+    if (!series.length) series.push({ id: uniqueChartSeriesId(series), name: "Values", values: [] });
+    series[0] = { ...series[0], values: tree.map(chartTreeTotal) };
+  }
   let palette = [...DEFAULT_CHART_PALETTE];
   if (Array.isArray(value.palette)) {
     const colors = value.palette.filter((c) => typeof c === "string" && c.trim() !== "");
@@ -655,6 +748,32 @@ function normalizeChartSpec(input) {
     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 highlight = [];
+  if (Array.isArray(value.highlight)) {
+    for (const h of value.highlight) {
+      if (typeof h === "string" || typeof h === "number") {
+        const name = String(h);
+        if (!highlight.includes(name)) highlight.push(name);
+      } else issues.push({ path: "highlight", message: "highlight must list category labels or series names." });
+    }
+  } else if (value.highlight !== void 0 && value.highlight !== null) issues.push({ path: "highlight", message: "highlight must be an array of category labels or series names." });
+  const listOf = (name, read) => {
+    const raw = value[name];
+    if (raw === void 0 || raw === null) return [];
+    if (!Array.isArray(raw)) {
+      issues.push({ path: name, message: `${name} must be an array.` });
+      return [];
+    }
+    return raw.map((item, i) => read(item, `${name}[${i}]`, issues)).filter((x) => x !== null);
+  };
+  const referenceLines = listOf("referenceLines", normalizeChartReferenceLine);
+  const referenceBands = listOf("referenceBands", normalizeChartReferenceBand);
+  let parliamentMajority = null;
+  if (value.parliamentMajority !== void 0 && value.parliamentMajority !== null) {
+    const m = Number(value.parliamentMajority);
+    if (Number.isInteger(m) && m >= 1) parliamentMajority = m;
+    else issues.push({ path: "parliamentMajority", message: "parliamentMajority must be a whole number of seats, 1 or more, or null for half plus one." });
+  }
   let radarTicks = null;
   if (value.radarTicks !== void 0 && value.radarTicks !== null) {
     const t = Number(value.radarTicks);
@@ -685,7 +804,19 @@ function normalizeChartSpec(input) {
     bins,
     showTotal: flag(value.showTotal, true, "showTotal", issues),
     radarTicks,
-    radarGraticule: pick(value.radarGraticule, CHART_RADAR_GRATICULES, "polygon", "radarGraticule", issues)
+    radarGraticule: pick(value.radarGraticule, CHART_RADAR_GRATICULES, "polygon", "radarGraticule", issues),
+    note: text(value.note, "", "note", issues),
+    highlight,
+    referenceLines,
+    referenceBands,
+    varyColors: flag(value.varyColors, false, "varyColors", issues),
+    likertNeutral: pick(value.likertNeutral, CHART_LIKERT_NEUTRALS, "split", "likertNeutral", issues),
+    likertSort: pick(value.likertSort, CHART_LIKERT_SORTS, "none", "likertSort", issues),
+    parliamentArc: fraction("parliamentArc", 180, 90, 360),
+    parliamentMajority,
+    parliamentLabel: text(value.parliamentLabel, "", "parliamentLabel", issues),
+    tree,
+    sunburstLabel: text(value.sunburstLabel, "", "sunburstLabel", issues)
   };
   if (spec.stacking === "percent")
     for (const name of ["yAxis", "yAxis2"]) {
@@ -705,7 +836,11 @@ function cloneChartSpec(spec) {
     yAxis: { ...spec.yAxis, format: { ...spec.yAxis.format } },
     yAxis2: { ...spec.yAxis2, format: { ...spec.yAxis2.format } },
     legend: { ...spec.legend },
-    palette: [...spec.palette]
+    palette: [...spec.palette],
+    highlight: [...spec.highlight],
+    referenceLines: spec.referenceLines.map((l) => ({ ...l })),
+    referenceBands: spec.referenceBands.map((b) => ({ ...b })),
+    tree: cloneChartTree(spec.tree)
   };
 }
 function cloneChartSeries(series) {
@@ -713,6 +848,7 @@ function cloneChartSeries(series) {
   if (series.x) copy.x = [...series.x];
   if (series.sizes) copy.sizes = [...series.sizes];
   if (series.pointColors) copy.pointColors = [...series.pointColors];
+  if (series.callouts) copy.callouts = [...series.callouts];
   if (series.format) copy.format = { ...series.format };
   if (series.trendlines) copy.trendlines = series.trendlines.map((t) => ({ ...t }));
   for (const name of ["errorBars", "xErrorBars"]) {
@@ -773,6 +909,206 @@ function chartColorInputValue(color) {
   return "#000000";
 }
 
+// src/chart/tree.ts
+var MAX_CHART_TREE_DEPTH = 6;
+var MAX_CHART_TREE_NODES = 5e3;
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function normalizeChartTree(value, issues = [], path = "tree") {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) {
+    issues.push({ path, message: `${path} must be an array of nodes such as {"name": "Europe", "children": [{"name": "France", "value": 40}]}.` });
+    return [];
+  }
+  let count = 0;
+  const read = (list, at, depth) => {
+    const out = [];
+    const names = /* @__PURE__ */ new Set();
+    list.forEach((raw, i) => {
+      const where = `${at}[${i}]`;
+      if (!isRecord2(raw)) {
+        issues.push({ path: where, message: `${where} must be an object with a name and a value or children.` });
+        return;
+      }
+      const name = typeof raw.name === "number" ? String(raw.name) : typeof raw.name === "string" ? raw.name.trim() : "";
+      if (!name) {
+        issues.push({ path: `${where}.name`, message: `${where} needs a name.` });
+        return;
+      }
+      if (names.has(name)) {
+        issues.push({ path: `${where}.name`, message: `"${name}" appears twice under the same group in ${at}; sibling names must be unique, so the second was left out.` });
+        return;
+      }
+      if (++count > MAX_CHART_TREE_NODES) {
+        if (count === MAX_CHART_TREE_NODES + 1) issues.push({ path, message: `The tree has more than ${MAX_CHART_TREE_NODES} nodes; the rest were left out.` });
+        return;
+      }
+      names.add(name);
+      for (const k of Object.keys(raw)) if (!["name", "value", "children", "color"].includes(k)) issues.push({ path: `${where}.${k}`, message: `${where} has no "${k}"; a node takes name, value, children and color.` });
+      const node = { name };
+      if (typeof raw.color === "string" && raw.color.trim()) node.color = raw.color.trim();
+      if (Array.isArray(raw.children) && raw.children.length) {
+        if (depth >= MAX_CHART_TREE_DEPTH) {
+          issues.push({ path: `${where}.children`, message: `${where} is more than ${MAX_CHART_TREE_DEPTH} levels deep; its children were left out.` });
+          node.value = 0;
+        } else {
+          if (raw.value !== void 0 && raw.value !== null) issues.push({ path: `${where}.value`, message: `"${name}" is a group: its value is the sum of its children, so the value given was ignored.` });
+          const children = read(raw.children, `${where}.children`, depth + 1);
+          if (children.length) node.children = children;
+          else node.value = 0;
+        }
+      } else {
+        if (raw.children !== void 0 && raw.children !== null && !Array.isArray(raw.children)) issues.push({ path: `${where}.children`, message: `${where}.children must be an array of nodes.` });
+        const v = parseChartValue(raw.value);
+        if (raw.value === void 0 || raw.value === null) node.value = 0;
+        else if (typeof v === "number" && v >= 0) node.value = v;
+        else {
+          issues.push({ path: `${where}.value`, message: `"${name}" needs a value of 0 or more; got ${JSON.stringify(raw.value)}.` });
+          node.value = 0;
+        }
+      }
+      out.push(node);
+    });
+    return out;
+  };
+  return read(value, path, 1);
+}
+function chartTreeTotal(node) {
+  return node.children ? node.children.reduce((t, c) => t + chartTreeTotal(c), 0) : node.value ?? 0;
+}
+function chartTreeDepth(tree) {
+  return tree.reduce((d, n) => Math.max(d, 1 + (n.children ? chartTreeDepth(n.children) : 0)), 0);
+}
+function findChartTreeNode(tree, path) {
+  let list = tree;
+  let node;
+  for (const name of path) {
+    node = list?.find((n) => n.name === name);
+    if (!node) return void 0;
+    list = node.children;
+  }
+  return node;
+}
+function chartTreeToRows(tree) {
+  const out = [];
+  const walk = (list, prefix) => {
+    for (const n of list) {
+      if (n.children) walk(n.children, [...prefix, n.name]);
+      else out.push({ path: [...prefix, n.name], value: n.value ?? 0 });
+    }
+  };
+  walk(tree, []);
+  return out;
+}
+function chartTreeFromRows(rows, issues = []) {
+  const tree = [];
+  rows.forEach((row, r) => {
+    const path = [];
+    for (const cell of row.path) {
+      const name = cell === null || cell === void 0 ? "" : String(cell).trim();
+      if (!name) break;
+      path.push(name);
+    }
+    if (!path.length) return;
+    if (path.length > MAX_CHART_TREE_DEPTH) {
+      issues.push({ path: `rows[${r}]`, message: `Row ${r + 1} is ${path.length} levels deep; the tree keeps at most ${MAX_CHART_TREE_DEPTH}, so the row was left out.` });
+      return;
+    }
+    const v = parseChartValue(row.value);
+    if (row.value !== null && row.value !== void 0 && String(row.value).trim() !== "" && !(typeof v === "number" && v >= 0)) {
+      issues.push({ path: `rows[${r}]`, message: `Row ${r + 1} (${path.join(" / ")}) needs a value of 0 or more; got ${JSON.stringify(row.value)}. It was counted as 0.` });
+    }
+    const value = typeof v === "number" && v >= 0 ? v : 0;
+    let list = tree;
+    for (let k = 0; k < path.length; k++) {
+      const last = k === path.length - 1;
+      let node = list.find((n) => n.name === path[k]);
+      if (!node) {
+        node = last ? { name: path[k], value } : { name: path[k], children: [] };
+        list.push(node);
+        if (last) return;
+      } else if (last) {
+        issues.push({ path: `rows[${r}]`, message: `Row ${r + 1} (${path.join(" / ")}) ${node.children ? "names a group that already has items" : "repeats an earlier row"}; it was left out.` });
+        return;
+      } else if (!node.children) {
+        issues.push({ path: `rows[${r}]`, message: `Row ${r + 1} puts items under "${path.slice(0, k + 1).join(" / ")}", which an earlier row made an item with its own value; it was left out.` });
+        return;
+      }
+      list = node.children;
+    }
+  });
+  return tree;
+}
+function chartTreeFromTable(rows, options = {}, issues = []) {
+  const grid = rows.filter((r) => r.some((c) => c !== null && c !== void 0 && String(c).trim() !== ""));
+  if (!grid.length) return [];
+  const width = Math.max(...grid.map((r) => r.length));
+  if (width < 2) {
+    issues.push({ path: "rows", message: "A tree table needs at least two columns: names, then values." });
+    return [];
+  }
+  const header = options.header ?? "auto";
+  const skip = header === true || header === "auto" && typeof parseChartValue(grid[0][width - 1]) !== "number";
+  const body = skip ? grid.slice(1) : grid;
+  let above = [];
+  return chartTreeFromRows(
+    body.map((r) => {
+      const cells = Array.from({ length: width - 1 }, (_, k) => r[k] === null || r[k] === void 0 ? "" : String(r[k]).trim());
+      const first = cells.findIndex((c) => c !== "");
+      if (first < 0) return { path: [], value: r[width - 1] };
+      const own = [];
+      for (const c of cells.slice(first)) {
+        if (!c) break;
+        own.push(c);
+      }
+      const path = [...above.slice(0, first), ...own];
+      above = path;
+      return { path, value: r[width - 1] };
+    }),
+    issues
+  );
+}
+function chartTreeFromSeries(categories, values) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  categories.forEach((c, i) => {
+    const name = c.trim() || `${i + 1}`;
+    if (seen.has(name)) return;
+    seen.add(name);
+    const v = values[i];
+    out.push({ name, value: v !== null && v !== void 0 && Number.isFinite(v) && v > 0 ? v : 0 });
+  });
+  return out;
+}
+function cloneChartTree(tree) {
+  return tree.map((n) => ({ ...n, ...n.children ? { children: cloneChartTree(n.children) } : {} }));
+}
+function chartTreeColumnLabels(depth) {
+  if (depth <= 1) return ["Item"];
+  return Array.from({ length: depth }, (_, k) => k === 0 ? "Group" : k === depth - 1 ? "Item" : `Level ${k + 1}`);
+}
+function setChartTreeRowName(rows, row, level, name) {
+  return rows.map((r, i) => {
+    if (i !== row) return { path: [...r.path], value: r.value };
+    const path = [...r.path];
+    while (path.length <= level) path.push("");
+    path[level] = name.trim();
+    return { path, value: r.value };
+  });
+}
+function setChartTreeRowValue(rows, row, value) {
+  return rows.map((r, i) => ({ path: [...r.path], value: i === row ? value : r.value }));
+}
+function addChartTreeRow(rows) {
+  const parent = rows.length ? rows[rows.length - 1].path.slice(0, -1) : [];
+  const taken = new Set(rows.filter((r) => r.path.length === parent.length + 1 && parent.every((p, k) => r.path[k] === p)).map((r) => r.path[parent.length]));
+  let n = rows.length + 1;
+  while (taken.has(`Item ${n}`)) n++;
+  return [...rows.map((r) => ({ path: [...r.path], value: r.value })), { path: [...parent, `Item ${n}`], value: 0 }];
+}
+function removeChartTreeRow(rows, row) {
+  return rows.filter((_, i) => i !== row).map((r) => ({ path: [...r.path], value: r.value }));
+}
+
 export {
   parseChartColor,
   chartRgbToHex,
@@ -795,6 +1131,22 @@ export {
   chartErrorBarsOfType,
   formatChartAmountList,
   parseChartAmountList,
+  MAX_CHART_TREE_DEPTH,
+  MAX_CHART_TREE_NODES,
+  normalizeChartTree,
+  chartTreeTotal,
+  chartTreeDepth,
+  findChartTreeNode,
+  chartTreeToRows,
+  chartTreeFromRows,
+  chartTreeFromTable,
+  chartTreeFromSeries,
+  cloneChartTree,
+  chartTreeColumnLabels,
+  setChartTreeRowName,
+  setChartTreeRowValue,
+  addChartTreeRow,
+  removeChartTreeRow,
   CHART_TYPES,
   CHART_MARKERS,
   CHART_TRENDLINE_TYPES,
@@ -805,6 +1157,9 @@ export {
   CHART_STACKINGS,
   CHART_CURVES,
   CHART_RADAR_GRATICULES,
+  CHART_LIKERT_NEUTRALS,
+  CHART_LIKERT_SORTS,
+  CHART_REFERENCE_AXES,
   CHART_ORIENTATIONS,
   CHART_LEGEND_POSITIONS,
   CHART_NUMBER_STYLES,
@@ -816,16 +1171,21 @@ export {
   isXyChart,
   chartFamily,
   chartColorsByCategory,
+  chartSpecColorsByCategory,
   defaultChartAxis,
   createChartSpec,
   chartSeriesColor,
+  chartLikertColor,
   chartSliceColor,
+  chartVariesColors,
   chartPointColor,
   chartSeriesType,
   uniqueChartSeriesId,
   parseChartValue,
   normalizeChartAxis,
   normalizeChartValues,
+  normalizeChartReferenceLine,
+  normalizeChartReferenceBand,
   normalizeChartErrorBars,
   normalizeChartTrendline,
   normalizeChartSpec,

package/dist/{chunk-EVPZ5IKN.js → chunk-5FNGLV2D.js}

@@ -6,15 +6,18 @@ import {
   CHART_ERROR_BAR_TYPES,
   CHART_LABEL_POSITIONS,
   CHART_LEGEND_POSITIONS,
+  CHART_LIKERT_NEUTRALS,
+  CHART_LIKERT_SORTS,
   CHART_MARKERS,
   CHART_NUMBER_STYLES,
   CHART_ORIENTATIONS,
   CHART_RADAR_GRATICULES,
+  CHART_REFERENCE_AXES,
   CHART_SERIES_TYPES,
   CHART_STACKINGS,
   CHART_TRENDLINE_TYPES,
   CHART_TYPES
-} from "./chunk-HLOKB7WW.js";
+} from "./chunk-3NEZJCBY.js";
 
 // src/chart/schemas.ts
 var VALUE = { type: ["number", "string", "null"], description: 'A number, numeric text ("1,200", "12%", "$40", "(3)") or null for a gap.' };
@@ -69,6 +72,46 @@ var TRENDLINE_PROPS = {
   name: { type: "string", description: 'Legend name (default e.g. "Linear (Sales)").' },
   color: { type: "string", description: "CSS colour (default: the series colour)." }
 };
+var REFERENCE_COMMON = {
+  label: { type: "string", description: 'Text written on it, e.g. "Target" (default none).' },
+  axis: {
+    type: "string",
+    enum: [...CHART_REFERENCE_AXES],
+    description: "Axis it is measured on: y (default) is the value axis, y2 the secondary value axis (needs a series there), x the numeric x axis of a scatter or bubble chart."
+  },
+  color: { type: "string", description: "CSS colour (default: the text colour)." }
+};
+var REFERENCE_LINE_PROPS = {
+  value: { type: "number", description: "Where the line crosses its axis, in data units." },
+  ...REFERENCE_COMMON
+};
+var REFERENCE_BAND_PROPS = {
+  from: { type: "number", description: "One end of the band on its axis, in data units." },
+  to: { type: "number", description: "The other end of the band, in data units (ends may come in either order)." },
+  ...REFERENCE_COMMON
+};
+var REFERENCE_COMMON_PATCH = {
+  label: { type: ["string", "null"], description: "Text written on it; null removes it." },
+  axis: { type: ["string", "null"], enum: [...CHART_REFERENCE_AXES, null], description: "Axis it is measured on (y, y2 or x); null goes back to y." },
+  color: { type: ["string", "null"], description: "CSS colour; null goes back to the text colour." }
+};
+var REFERENCE_LINE_PATCH = { value: REFERENCE_LINE_PROPS.value, ...REFERENCE_COMMON_PATCH };
+var REFERENCE_BAND_PATCH = { from: REFERENCE_BAND_PROPS.from, to: REFERENCE_BAND_PROPS.to, ...REFERENCE_COMMON_PATCH };
+var REFERENCE_INDEX = (what) => ({ type: "integer", minimum: 0, description: `${what} index (0 = first), as get_chart lists them in spec.${what === "Reference line" ? "referenceLines" : "referenceBands"}.` });
+var TREE_NODE = {
+  type: "object",
+  description: 'An item ({"name", "value"}) or a group ({"name", "children": [nodes]}, whose value is the sum of its items).',
+  properties: {
+    name: { type: "string", description: "Label; unique among its siblings." },
+    value: { type: "number", minimum: 0, description: "Items only: the amount, 0 or more." },
+    children: { type: "array", items: { $ref: "#/$defs/chartTreeNode" }, description: "Groups only: the nodes inside it (up to 6 levels in all)." },
+    color: { type: "string", description: "CSS colour (default: the palette colour of its top-level group, lighter further in)." }
+  },
+  required: ["name"],
+  additionalProperties: false
+};
+var TREE_DEFS = { chartTreeNode: TREE_NODE };
+var TREE_PATH = { type: "array", items: { type: "string" }, minItems: 1, description: 'Names from the top level down to the node, e.g. ["Europe", "France"] (from get_chart treeTable or spec.tree).' };
 var ERROR_BARS = (what) => ({
   type: ["object", "null"],
   description: `${what} null removes them.`,
@@ -97,6 +140,7 @@ var SERIES_PROPS = {
   x: { type: ["array", "null"], items: VALUE, description: "Numeric x per category, for scatter and bubble charts." },
   sizes: { type: ["array", "null"], items: VALUE, description: "Bubble sizes per category (area is proportional to size)." },
   pointColors: { type: ["array", "null"], items: { type: ["string", "null"] }, description: "Colour per category (null keeps the series colour)." },
+  callouts: { type: ["array", "null"], items: { type: ["string", "null"] }, description: "A label pinned to each point that matters, one per category (null: none); null removes them all. Bar, line, area and scatter charts. set_chart_callout sets one." },
   marker: { type: ["string", "null"], enum: [...CHART_MARKERS, null], description: "Point marker shape for line, area and scatter series." },
   curve: { type: ["string", "null"], enum: [...CHART_CURVES, null], description: "Line shape for this series: linear, smooth or step." },
   dataLabels: { type: ["boolean", "null"], description: "Value labels for this series (null follows the chart)." },
@@ -105,7 +149,7 @@ var SERIES_PROPS = {
   xErrorBars: ERROR_BARS("Error bars along the x axis (scatter and bubble charts with numeric x values; amounts in x units).")
 };
 var CHART_UPDATE_PROPERTIES = {
-  type: { type: "string", enum: [...CHART_TYPES], description: "Chart type." },
+  type: { type: "string", enum: [...CHART_TYPES], description: "Chart type. slope joins each category from the first series (before) to the second (after); likert reads each category as a question and the series as answers from most negative to most positive; parliament draws the first series as seats; sunburst draws the grouped data (set_chart_tree) as rings, and a treemap with grouped data nests its groups." },
   title: { type: "string", description: 'Title ("" for none).' },
   subtitle: { type: "string", description: 'Subtitle ("" for none).' },
   xAxis: AXIS("Category axis (or numeric x axis of scatter / bubble charts)."),
@@ -130,7 +174,18 @@ var CHART_UPDATE_PROPERTIES = {
   bins: { type: ["integer", "null"], minimum: 1, maximum: 500, description: "Histogram bin count, or null for \u221An." },
   showTotal: { type: "boolean", description: "Waterfall: append a total bar." },
   radarTicks: { type: ["integer", "null"], minimum: 1, maximum: 50, description: "Radar: number of evenly spaced rings from the value axis min to max, or null for round-number rings (default null)." },
-  radarGraticule: { type: "string", enum: [...CHART_RADAR_GRATICULES], description: "Radar: draw rings as polygons through the spokes or as circles (default polygon)." }
+  radarGraticule: { type: "string", enum: [...CHART_RADAR_GRATICULES], description: "Radar: draw rings as polygons through the spokes or as circles (default polygon)." },
+  note: { type: "string", description: 'A source or footnote written under the chart ("" for none).' },
+  highlight: { type: "array", items: { type: "string" }, description: "Category labels and series names (or ids) to draw normally while the rest are muted; [] shows everything. highlight_chart checks the names." },
+  referenceLines: { type: "array", items: { type: "object", properties: REFERENCE_LINE_PROPS, required: ["value"], additionalProperties: false }, description: "Replaces every reference line (targets, floors, averages across the plot). add_chart_reference_line adds one." },
+  referenceBands: { type: "array", items: { type: "object", properties: REFERENCE_BAND_PROPS, required: ["from", "to"], additionalProperties: false }, description: "Replaces every reference band (target ranges across the plot). add_chart_reference_band adds one." },
+  varyColors: { type: "boolean", description: "A one-series bar, line, area or scatter chart colours each category from the palette, and its legend lists the categories (default false)." },
+  likertNeutral: { type: "string", enum: [...CHART_LIKERT_NEUTRALS], description: "Likert with an odd number of answers: split (default) puts the middle answer across the centre line; separate draws it in its own column on the right." },
+  likertSort: { type: "string", enum: [...CHART_LIKERT_SORTS], description: "Likert: order the questions by agreement (positive), by disagreement (negative) or as given (none, default)." },
+  parliamentArc: { type: "number", minimum: 90, maximum: 360, description: "Parliament: sweep of the hemicycle in degrees (default 180)." },
+  parliamentMajority: { type: ["integer", "null"], minimum: 1, description: "Parliament: seats needed for a majority, drawn as a dashed line (null: half of the seats plus one)." },
+  parliamentLabel: { type: "string", description: 'Parliament: caption under the seat total ("" writes "seats").' },
+  sunburstLabel: { type: "string", description: 'Sunburst: caption under the total in the centre ("" for none).' }
 };
 
 export {
@@ -140,6 +195,13 @@ export {
   WIDTH,
   HEIGHT,
   TRENDLINE_PROPS,
+  REFERENCE_LINE_PROPS,
+  REFERENCE_BAND_PROPS,
+  REFERENCE_LINE_PATCH,
+  REFERENCE_BAND_PATCH,
+  REFERENCE_INDEX,
+  TREE_DEFS,
+  TREE_PATH,
   SERIES_PROPS,
   CHART_UPDATE_PROPERTIES
 };