@rowsncolumns/charts 28.1.7 → 28.1.10

package/dist/esm/utils/hierarchy.js

@@ -16,10 +16,6 @@ const toLabelString = (value) => {
         return "";
     return `${value}`.trim();
 };
-const toParentLabel = (value) => {
-    const label = toLabelString(value);
-    return label === "" ? null : label;
-};
 const toNumericValue = (value) => {
     if (typeof value === "number" && Number.isFinite(value)) {
         return value;
@@ -50,71 +46,178 @@ export const getHierarchyHeaderTitle = (spec, options) => {
     }
     return undefined;
 };
+/**
+ * Lay the rows out as Excel does: one column per level (`parentLabels`
+ * entries, top level first) and the label column as the innermost level.
+ * Returns, per row, the filled level cells up to the row's leaf.
+ *
+ * A blank level cell BEFORE the row's first filled cell means "same as the
+ * row above" (Excel writes a parent only on the first row of its group).
+ * A blank AFTER the last filled cell ends the branch there — that cell is
+ * the row's leaf, so a shorter branch (`Services | Training | <blank>`)
+ * is a leaf of the second level, not `Services > Training > <previous
+ * item>` as plain per-column fill-down would make it.
+ */
+const layoutHierarchyLevels = (levelColumns, rowCount) => {
+    const filled = [];
+    let above = levelColumns.map(() => "");
+    for (let row = 0; row < rowCount; row++) {
+        const cells = levelColumns.map((column) => column[row] ?? "");
+        const firstFilled = cells.findIndex((cell) => cell !== "");
+        if (firstFilled === -1) {
+            // An entirely blank row defines nothing (and inherits nothing).
+            filled.push([]);
+            continue;
+        }
+        const effective = cells.map((cell, level) => level < firstFilled ? above[level] ?? "" : cell);
+        let lastFilled = effective.length - 1;
+        while (lastFilled >= 0 && effective[lastFilled] === "")
+            lastFilled--;
+        // The row's own levels end at its last filled cell; the cells past it
+        // stay blank for the rows below (they inherit up to the leaf only).
+        above = effective.map((cell, level) => (level <= lastFilled ? cell : ""));
+        filled.push(effective.slice(0, lastFilled + 1).filter((cell) => cell !== ""));
+    }
+    return filled;
+};
 export const extractHierarchyRows = (spec, options) => {
     const { getDomainValuesFromRange, getSeriesValuesFromRange } = options;
     const hiddenStrategy = options.hiddenDimensionStrategy;
     const skipHeaders = spec.useFirstRowAsHeaders !== false;
     const labels = flattenChartData(spec.labels, getDomainValuesFromRange, hiddenStrategy, skipHeaders).map(toLabelString);
-    const parents = flattenChartData(spec.parentLabels, getDomainValuesFromRange, hiddenStrategy, skipHeaders);
+    // Each `parentLabels` entry is one hierarchy level (top level first).
+    const parentLevels = (spec.parentLabels ?? []).map((entry) => flattenChartData([entry], getDomainValuesFromRange, hiddenStrategy, skipHeaders).map(toLabelString));
     const sizes = flattenChartData(spec.sizeData, getSeriesValuesFromRange, hiddenStrategy, skipHeaders);
+    // A single parent column whose values name other rows' labels is a flat
+    // adjacency list (Google Sheets' label / parent-label model): every row
+    // is its own node and a blank parent means a root. Excel's level layout
+    // never lists a level name in the label column.
+    const labelSet = new Set(labels.filter((label) => label !== ""));
+    const isAdjacencyList = parentLevels.length === 1 &&
+        parentLevels[0].some((parent) => parent !== "" && labelSet.has(parent));
     const rows = [];
-    const seenLabels = new Set();
-    for (let i = 0; i < labels.length; i++) {
-        const label = labels[i];
-        if (!label)
+    const seenPaths = new Set();
+    if (isAdjacencyList) {
+        const parents = parentLevels[0];
+        for (let i = 0; i < labels.length; i++) {
+            const label = labels[i];
+            if (!label)
+                continue;
+            if (seenPaths.has(label)) {
+                throw new Error(`Duplicate hierarchy label detected: ${label}`);
+            }
+            seenPaths.add(label);
+            const parent = parents[i] ?? "";
+            rows.push({
+                label,
+                parent: parent === "" ? null : parent,
+                value: toNumericValue(sizes[i]),
+            });
+        }
+        return rows;
+    }
+    const rowCount = Math.max(labels.length, ...parentLevels.map((level) => level.length));
+    const levels = layoutHierarchyLevels([...parentLevels, labels], rowCount);
+    for (let i = 0; i < rowCount; i++) {
+        const cells = levels[i];
+        if (!cells || cells.length === 0)
             continue;
-        if (seenLabels.has(label)) {
+        const label = cells[cells.length - 1];
+        const path = cells.slice(0, -1);
+        const key = [...path, label].join("\u0000");
+        if (seenPaths.has(key)) {
             throw new Error(`Duplicate hierarchy label detected: ${label}`);
         }
-        seenLabels.add(label);
+        seenPaths.add(key);
         rows.push({
             label,
-            parent: toParentLabel(parents[i]),
+            parent: path.length ? path[path.length - 1] : null,
             value: toNumericValue(sizes[i]),
+            path,
         });
     }
     return rows;
 };
-const getOrCreateNode = (nodes, name) => {
-    const existing = nodes.get(name);
-    if (existing)
-        return existing;
-    const node = {
-        name,
-        value: 0,
-        parent: null,
-        children: new Set(),
+const PATH_SEPARATOR = "/";
+/**
+ * The full path of every row, top level first, ending with the row's own
+ * label. A row carrying `path` (Excel's level layout) is placed under it;
+ * a legacy adjacency row names its parent, which is another row's label,
+ * so its path is that row's path plus itself (chained up to a root).
+ */
+const resolveRowPaths = (rows) => {
+    const byLabel = new Map();
+    rows.forEach((row) => {
+        if (row.label && !row.path && !byLabel.has(row.label)) {
+            byLabel.set(row.label, row);
+        }
+    });
+    const memo = new Map();
+    const resolve = (row, visiting) => {
+        const cached = memo.get(row);
+        if (cached)
+            return cached;
+        let path;
+        if (row.path) {
+            path = [...row.path, row.label];
+        }
+        else {
+            const parentName = row.parent && row.parent !== row.label ? row.parent : null;
+            const parentRow = parentName ? byLabel.get(parentName) : undefined;
+            if (parentRow && parentRow !== row && !visiting.has(parentRow)) {
+                visiting.add(row);
+                path = [...resolve(parentRow, visiting), row.label];
+                visiting.delete(row);
+            }
+            else {
+                path = parentName ? [parentName, row.label] : [row.label];
+            }
+        }
+        memo.set(row, path);
+        return path;
     };
-    nodes.set(name, node);
-    return node;
+    return rows.map((row) => resolve(row, new Set()));
 };
 export const buildHierarchyTree = (rows) => {
-    const nodes = new Map();
-    rows.forEach((row) => {
+    const roots = new Map();
+    const nodeAt = (path) => {
+        let level = roots;
+        let node;
+        path.forEach((name, depth) => {
+            const existing = level.get(name);
+            if (existing) {
+                node = existing;
+            }
+            else {
+                node = {
+                    name,
+                    id: path.slice(0, depth + 1).join(PATH_SEPARATOR),
+                    value: 0,
+                    children: new Map(),
+                };
+                level.set(name, node);
+            }
+            level = node.children;
+        });
+        return node;
+    };
+    const paths = resolveRowPaths(rows);
+    rows.forEach((row, index) => {
         if (!row.label)
             return;
-        const labelNode = getOrCreateNode(nodes, row.label);
-        const numericValue = row.value ?? 0;
-        labelNode.value += numericValue;
-        const parentName = row.parent && row.parent !== row.label ? row.parent : null;
-        if (parentName) {
-            const parentNode = getOrCreateNode(nodes, parentName);
-            parentNode.children.add(row.label);
-            if (labelNode.parent == null) {
-                labelNode.parent = parentName;
-            }
-        }
+        const node = nodeAt(paths[index]);
+        node.value += row.value ?? 0;
     });
     const buildNode = (internal) => {
         const children = internal.children.size > 0
-            ? Array.from(internal.children).map((childName) => buildNode(getOrCreateNode(nodes, childName)))
+            ? Array.from(internal.children.values()).map(buildNode)
             : undefined;
         const value = children && children.length > 0
             ? children.reduce((sum, child) => sum + (child.value ?? 0), 0)
             : internal.value;
         const node = {
             name: internal.name,
-            id: internal.name,
+            id: internal.id,
             value,
         };
         if (children && children.length > 0) {
@@ -122,29 +225,44 @@ export const buildHierarchyTree = (rows) => {
         }
         return node;
     };
-    const roots = [];
-    nodes.forEach((internal) => {
-        if (internal.parent == null) {
-            roots.push(buildNode(internal));
-        }
-    });
-    return roots;
+    return Array.from(roots.values()).map(buildNode);
 };
 export const toPlotlyHierarchy = (rows) => {
     const tree = buildHierarchyTree(rows);
     const labels = [];
+    const ids = [];
     const parents = [];
     const values = [];
-    const traverse = (nodes, parentName) => {
+    const depths = [];
+    const traverse = (nodes, parentId, depth) => {
         nodes.forEach((node) => {
             labels.push(node.name);
-            parents.push(parentName ?? "");
+            ids.push(node.id ?? node.name);
+            parents.push(parentId);
             values.push(node.value ?? 0);
+            depths.push(depth);
             if (node.children) {
-                traverse(node.children, node.name);
+                traverse(node.children, node.id ?? node.name, depth + 1);
             }
         });
     };
-    traverse(tree, null);
-    return { labels, parents, values };
+    traverse(tree, "", 0);
+    return { labels, ids, parents, values, depths };
+};
+/**
+ * One solid colour per top-level category, inherited by every descendant
+ * (Excel colours a treemap / sunburst by its first level), in tree order.
+ * Returns the colour per node of `toPlotlyHierarchy`'s flat arrays.
+ */
+export const hierarchyNodeColors = (hierarchy, palette) => {
+    const colorById = new Map();
+    let rootIndex = 0;
+    return hierarchy.ids.map((id, index) => {
+        const parentId = hierarchy.parents[index];
+        const color = parentId === ""
+            ? palette[rootIndex++ % Math.max(1, palette.length)] ?? ""
+            : colorById.get(parentId) ?? "";
+        colorById.set(id, color);
+        return color;
+    });
 };

package/dist/esm/utils/overrides.d.ts

@@ -9,6 +9,15 @@ export declare const applyLegendOverrides: (legend: LegendComponentOption, opts:
  */
 export declare const applyAxisOverrides: (axis: any, opts: any, numberFormatPattern?: string, locale?: string) => any;
 export declare const dataLabelFormatter: (opts: any, locale?: string) => (params: any) => string;
+/**
+ * The data-label options one series renders with: its own
+ * `ChartData.dataLabels` when it has them (OOXML's `<c:ser><c:dLbls>`
+ * override — `{ show: false }` turns a labelled chart's labels off for
+ * that series alone), else the chart-level `ChartSpec.dataLabels`.
+ */
+export declare const resolveSeriesDataLabels: <T>(chartLevel: T | null | undefined, series: {
+    dataLabels?: T | null;
+} | null | undefined) => T | null | undefined;
 export declare const buildSeriesLabelOption: (opts: any, seriesType?: string, locale?: string) => {
     readonly show: true;
     readonly position: any;

package/dist/esm/utils/overrides.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"overrides.d.ts","sourceRoot":"","sources":["../../../utils/overrides.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAWrD,oEAAoE;AACpE,eAAO,MAAM,4BAA4B,GAAI,KAAK,GAAG,oCASpD,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,qBAAqB,EAC7B,MAAM,GAAG,KACR,qBA6CF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAC7B,MAAM,GAAG,EACT,MAAM,GAAG,EACT,sBAAsB,MAAM,EAC5B,SAAS,MAAM,QA4BhB,CAAC;AAgBF,eAAO,MAAM,kBAAkB,GAAI,MAAM,GAAG,EAAE,SAAS,MAAM,MAAM,QAAQ,GAAG,WAiC7E,CAAC;AAgCF,eAAO,MAAM,sBAAsB,GACjC,MAAM,GAAG,EACT,aAAa,MAAM,EACnB,SAAS,MAAM;;;iCApE0D,GAAG;aAiF7E,CAAC"}
+{"version":3,"file":"overrides.d.ts","sourceRoot":"","sources":["../../../utils/overrides.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAWrD,oEAAoE;AACpE,eAAO,MAAM,4BAA4B,GAAI,KAAK,GAAG,oCASpD,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,qBAAqB,EAC7B,MAAM,GAAG,KACR,qBA6CF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAC7B,MAAM,GAAG,EACT,MAAM,GAAG,EACT,sBAAsB,MAAM,EAC5B,SAAS,MAAM,QA4BhB,CAAC;AAgBF,eAAO,MAAM,kBAAkB,GAAI,MAAM,GAAG,EAAE,SAAS,MAAM,MAAM,QAAQ,GAAG,WA+C7E,CAAC;AAgCF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAAI,CAAC,EACvC,YAAY,CAAC,GAAG,IAAI,GAAG,SAAS,EAChC,QAAQ;IAAE,UAAU,CAAC,EAAE,CAAC,GAAG,IAAI,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,KACnD,CAAC,GAAG,IAAI,GAAG,SAA6C,CAAC;AAE5D,eAAO,MAAM,sBAAsB,GACjC,MAAM,GAAG,EACT,aAAa,MAAM,EACnB,SAAS,MAAM;;;iCA7F0D,GAAG;aA0G7E,CAAC"}

package/dist/esm/utils/overrides.js

@@ -132,7 +132,11 @@ export const dataLabelFormatter = (opts, locale) => (params) => {
         !opts.showSeriesName
         ? true
         : !!opts.showValue;
-    if (showVal && params.value !== undefined) {
+    // A scatter / bubble point's value is its [x, y, size] tuple: the label's
+    // value is Y and the bubble size is the third entry (#1068).
+    const isPointTuple = Array.isArray(params.value);
+    const pointValue = isPointTuple ? params.value[1] : params.value;
+    if (showVal && pointValue !== undefined) {
         // PERCENT_STACKED stores the raw value on the data object so the
         // label can still surface the dollar amount instead of the
         // normalized percentage. Plain stacked / clustered have just a
@@ -140,7 +144,10 @@ export const dataLabelFormatter = (opts, locale) => (params) => {
         const originalValue = typeof params.data === "object" && params.data
             ? params.data.originalValue
             : undefined;
-        parts.push(formatLabelValue(params.value, originalValue, opts.numberFormatPattern, locale));
+        parts.push(formatLabelValue(pointValue, originalValue, opts.numberFormatPattern, locale));
+    }
+    if (opts.showBubbleSize && isPointTuple && params.value.length > 2) {
+        parts.push(formatLabelValue(params.value[2], undefined, opts.numberFormatPattern, locale));
     }
     return parts.join(": ");
 };
@@ -173,6 +180,13 @@ const ECHARTS_POINT_DLBL_POS = {
     right: "right",
 };
 const POINT_SERIES_TYPES = new Set(["line", "scatter", "effectScatter"]);
+/**
+ * The data-label options one series renders with: its own
+ * `ChartData.dataLabels` when it has them (OOXML's `<c:ser><c:dLbls>`
+ * override — `{ show: false }` turns a labelled chart's labels off for
+ * that series alone), else the chart-level `ChartSpec.dataLabels`.
+ */
+export const resolveSeriesDataLabels = (chartLevel, series) => series?.dataLabels ?? chartLevel;
 export const buildSeriesLabelOption = (opts, seriesType, locale) => {
     if (!opts?.show)
         return undefined;

package/dist/esm/utils/radar.d.ts

@@ -16,15 +16,41 @@ export type RadarSeriesInput = {
 };
 export type RadarIndicator = {
     name: string;
+    min: number;
     max: number;
 };
+export type RadarAxisScale = {
+    min: number;
+    max: number;
+};
+/** The value-axis options a radar's common scale reads (`ChartAxisOptions`). */
+export type RadarAxisOptions = {
+    min?: number | null;
+    max?: number | null;
+    visible?: boolean | null;
+} | null | undefined;
+/**
+ * The next "nice" axis bound at or above `value` — the top tick a value
+ * axis would auto-scale to: the step is 1 / 2 / 5 × a power of ten sized
+ * for about five divisions, and the bound is the first multiple of that
+ * step at or above the value (9 → 10, 33 → 40, 0.7 → 0.8).
+ */
+export declare const niceAxisCeiling: (value: number) => number;
+/**
+ * One value scale shared by every radar axis, as Excel draws it: `max` is
+ * the spec's `valueAxisOptions.max` when set, else the largest value across
+ * all series and categories rounded up to a nice bound (never below 1);
+ * `min` is `valueAxisOptions.min` when set (and below `max`), else 0.
+ */
+export declare const radarValueScale: (series: RadarSeriesInput[], axisOptions?: RadarAxisOptions) => RadarAxisScale;
 /**
- * Build echarts radar indicators from category labels and series.
- * The `max` per indicator is the largest value seen across all series at
- * that category (rounded up a touch so the polygon doesn't touch the
- * rim). When every series is empty at an index, `max` defaults to 1.
+ * Build echarts radar indicators from category labels and series. Every
+ * indicator carries the SAME `min` / `max` — the common scale of
+ * {@link radarValueScale} — so values on different axes compare, and a
+ * single series draws the shape of its data rather than a regular polygon
+ * (rowsncolumns/spreadsheet#1066).
  */
-export declare const buildRadarIndicators: (categories: (string | number | boolean | null | undefined)[], series: RadarSeriesInput[]) => RadarIndicator[];
+export declare const buildRadarIndicators: (categories: (string | number | boolean | null | undefined)[], series: RadarSeriesInput[], axisOptions?: RadarAxisOptions) => RadarIndicator[];
 /**
  * Shape series into echarts radar data: one entry per series with its
  * value vector aligned to the indicator order. Missing/non-numeric

package/dist/esm/utils/radar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"radar.d.ts","sourceRoot":"","sources":["../../../utils/radar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAQ3D;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,YAAY,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EAC5D,QAAQ,gBAAgB,EAAE,KACzB,cAAc,EAahB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,gBAAgB,EAAE,EAC1B,gBAAgB,MAAM,KACrB,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAQzC,CAAC"}
+{"version":3,"file":"radar.d.ts","sourceRoot":"","sources":["../../../utils/radar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAQxE,MAAM,MAAM,cAAc,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1D,gFAAgF;AAChF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC1B,GAAG,IAAI,GAAG,SAAS,CAAC;AAErB;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,KAAG,MAW/C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAC1B,QAAQ,gBAAgB,EAAE,EAC1B,cAAc,gBAAgB,KAC7B,cAaF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAC/B,YAAY,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EAC5D,QAAQ,gBAAgB,EAAE,EAC1B,cAAc,gBAAgB,KAC7B,cAAc,EAGhB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,gBAAgB,EAAE,EAC1B,gBAAgB,MAAM,KACrB,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAQzC,CAAC"}

package/dist/esm/utils/radar.js

@@ -13,25 +13,53 @@
 const isFiniteNum = (v) => typeof v === "number" && Number.isFinite(v);
 const toNumber = (v) => isFiniteNum(v) ? v : 0;
 /**
- * Build echarts radar indicators from category labels and series.
- * The `max` per indicator is the largest value seen across all series at
- * that category (rounded up a touch so the polygon doesn't touch the
- * rim). When every series is empty at an index, `max` defaults to 1.
+ * The next "nice" axis bound at or above `value` — the top tick a value
+ * axis would auto-scale to: the step is 1 / 2 / 5 × a power of ten sized
+ * for about five divisions, and the bound is the first multiple of that
+ * step at or above the value (9 → 10, 33 → 40, 0.7 → 0.8).
  */
-export const buildRadarIndicators = (categories, series) => {
-    return categories.map((label, i) => {
-        let max = 0;
-        for (const s of series) {
-            const v = s.values[i];
+export const niceAxisCeiling = (value) => {
+    if (!isFiniteNum(value) || value <= 0)
+        return 1;
+    const rough = value / 5;
+    const magnitude = 10 ** Math.floor(Math.log10(rough));
+    const residual = rough / magnitude;
+    const step = (residual <= 1 ? 1 : residual <= 2 ? 2 : residual <= 5 ? 5 : 10) *
+        magnitude;
+    const ceiling = Math.ceil(value / step - 1e-9) * step;
+    // Avoid 0.30000000000000004-style bounds from the float arithmetic.
+    return Number(ceiling.toPrecision(12));
+};
+/**
+ * One value scale shared by every radar axis, as Excel draws it: `max` is
+ * the spec's `valueAxisOptions.max` when set, else the largest value across
+ * all series and categories rounded up to a nice bound (never below 1);
+ * `min` is `valueAxisOptions.min` when set (and below `max`), else 0.
+ */
+export const radarValueScale = (series, axisOptions) => {
+    let largest = 0;
+    for (const s of series) {
+        for (const v of s.values) {
             if (isFiniteNum(v))
-                max = Math.max(max, v);
+                largest = Math.max(largest, v);
         }
-        return {
-            name: String(label ?? ""),
-            // Pad by 10% so the outermost ring has breathing room; never 0.
-            max: max > 0 ? max * 1.1 : 1,
-        };
-    });
+    }
+    const max = isFiniteNum(axisOptions?.max)
+        ? axisOptions.max
+        : niceAxisCeiling(largest);
+    const min = isFiniteNum(axisOptions?.min) && axisOptions.min < max ? axisOptions.min : 0;
+    return { min, max };
+};
+/**
+ * Build echarts radar indicators from category labels and series. Every
+ * indicator carries the SAME `min` / `max` — the common scale of
+ * {@link radarValueScale} — so values on different axes compare, and a
+ * single series draws the shape of its data rather than a regular polygon
+ * (rowsncolumns/spreadsheet#1066).
+ */
+export const buildRadarIndicators = (categories, series, axisOptions) => {
+    const { min, max } = radarValueScale(series, axisOptions);
+    return categories.map((label) => ({ name: String(label ?? ""), min, max }));
 };
 /**
  * Shape series into echarts radar data: one entry per series with its

package/dist/esm/utils/trendline.d.ts

@@ -43,6 +43,12 @@ export type TrendlineResult = {
  * @param values  Raw y-values; the 1-based category position is used as x
  *                for the fit, the 0-based index is reported in the points.
  * @param spec    Trendline parameters (type/order/period/forecast).
+ * @param xValues Scatter / bubble only — the series' real X values, index-
+ *                aligned with `values`. The fit then runs on (x, y) pairs
+ *                (a regression of Y on X, what Excel draws on an XY chart;
+ *                the point index is wrong for unevenly spaced X), the
+ *                forecast extends the X range by that many X units, and the
+ *                points carry real X coordinates sampled across the range.
  */
 export declare const computeTrendline: (values: (number | null | undefined)[], spec?: {
     type?: TrendlineType | null;
@@ -50,5 +56,5 @@ export declare const computeTrendline: (values: (number | null | undefined)[], s
     period?: number | null;
     forecastForward?: number | null;
     forecastBackward?: number | null;
-}) => TrendlineResult | null;
+}, xValues?: (number | null | undefined)[] | null) => TrendlineResult | null;
 //# sourceMappingURL=trendline.d.ts.map

package/dist/esm/utils/trendline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trendline.d.ts","sourceRoot":"","sources":["../../../utils/trendline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,MAAM,MAAM,aAAa,GACrB,QAAQ,GACR,KAAK,GACL,KAAK,GACL,MAAM,GACN,OAAO,GACP,WAAW,CAAC;AAEhB,6FAA6F;AAC7F,MAAM,MAAM,cAAc,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtD,MAAM,MAAM,eAAe,GAAG;IAC5B,sEAAsE;IACtE,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,uEAAuE;IACvE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB,CAAC;AAsJF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACrC,OAAM;IACJ,IAAI,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,KACL,eAAe,GAAG,IAiGpB,CAAC"}
+{"version":3,"file":"trendline.d.ts","sourceRoot":"","sources":["../../../utils/trendline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,MAAM,MAAM,aAAa,GACrB,QAAQ,GACR,KAAK,GACL,KAAK,GACL,MAAM,GACN,OAAO,GACP,WAAW,CAAC;AAEhB,6FAA6F;AAC7F,MAAM,MAAM,cAAc,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtD,MAAM,MAAM,eAAe,GAAG;IAC5B,sEAAsE;IACtE,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,uEAAuE;IACvE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB,CAAC;AAkKF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACrC,OAAM;IACJ,IAAI,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,EACN,UAAU,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,GAAG,IAAI,KAC7C,eAAe,GAAG,IA+HpB,CAAC"}

package/dist/esm/utils/trendline.js

@@ -29,15 +29,25 @@ const isFiniteNum = (v) => typeof v === "number" && Number.isFinite(v);
  * position as x (the first category is x = 1, see the module comment).
  * Non-finite y-values are dropped (they cannot be fitted).
  */
-const toPairs = (values) => {
+const toPairs = (values, xValues) => {
     const pairs = [];
     for (let i = 0; i < values.length; i++) {
         const y = values[i];
-        if (isFiniteNum(y))
+        if (!isFiniteNum(y))
+            continue;
+        if (xValues) {
+            const x = xValues[i];
+            if (isFiniteNum(x))
+                pairs.push({ x, y });
+        }
+        else {
             pairs.push({ x: i + 1, y });
+        }
     }
     return pairs;
 };
+/** Samples along a scatter trendline's x range: enough for the curved fits to read as curves. */
+const XY_TRENDLINE_SAMPLES = 64;
 /** Compute R² between observed y and predicted f(x) over the fit pairs. */
 const rSquaredOf = (pairs, predict) => {
     if (pairs.length < 2)
@@ -177,14 +187,22 @@ const fitPower = (pairs) => {
  * @param values  Raw y-values; the 1-based category position is used as x
  *                for the fit, the 0-based index is reported in the points.
  * @param spec    Trendline parameters (type/order/period/forecast).
+ * @param xValues Scatter / bubble only — the series' real X values, index-
+ *                aligned with `values`. The fit then runs on (x, y) pairs
+ *                (a regression of Y on X, what Excel draws on an XY chart;
+ *                the point index is wrong for unevenly spaced X), the
+ *                forecast extends the X range by that many X units, and the
+ *                points carry real X coordinates sampled across the range.
  */
-export const computeTrendline = (values, spec = {}) => {
-    const pairs = toPairs(values);
+export const computeTrendline = (values, spec = {}, xValues) => {
+    const pairs = toPairs(values, xValues);
     if (pairs.length < 2)
         return null;
     const type = spec.type ?? "linear";
-    const forward = Math.max(0, Math.floor(spec.forecastForward ?? 0));
-    const backward = Math.max(0, Math.floor(spec.forecastBackward ?? 0));
+    const forwardRaw = Math.max(0, spec.forecastForward ?? 0);
+    const backwardRaw = Math.max(0, spec.forecastBackward ?? 0);
+    const forward = xValues ? forwardRaw : Math.floor(forwardRaw);
+    const backward = xValues ? backwardRaw : Math.floor(backwardRaw);
     // Moving average is a smoothing of the observed values, not a fitted
     // function, so it is handled separately and ignores forecasting.
     if (type === "movingAvg") {
@@ -200,17 +218,51 @@ export const computeTrendline = (values, spec = {}) => {
                     count++;
                 }
             }
-            if (count > 0)
+            if (count === 0)
+                continue;
+            if (xValues) {
+                const x = xValues[i];
+                if (isFiniteNum(x))
+                    points.push({ x, y: sum / count });
+            }
+            else {
                 points.push({ x: i, y: sum / count });
+            }
         }
+        if (xValues)
+            points.sort((a, b) => a.x - b.x);
         return { points, rSquared: null, equation: null };
     }
-    // Fit domain is 1..n; a forecast of k periods extends it to 1−k / n+k.
-    const xStart = 1 - backward;
-    const xEnd = values.length + forward;
     const xs = [];
-    for (let x = xStart; x <= xEnd; x++)
-        xs.push(x);
+    if (xValues) {
+        // Sample the fitted curve across the data's X range, extended by the
+        // forecast in X units.
+        let minX = Infinity;
+        let maxX = -Infinity;
+        for (const p of pairs) {
+            if (p.x < minX)
+                minX = p.x;
+            if (p.x > maxX)
+                maxX = p.x;
+        }
+        const xStart = minX - backward;
+        const xEnd = maxX + forward;
+        if (xEnd > xStart) {
+            for (let i = 0; i <= XY_TRENDLINE_SAMPLES; i++) {
+                xs.push(xStart + ((xEnd - xStart) * i) / XY_TRENDLINE_SAMPLES);
+            }
+        }
+        else {
+            xs.push(xStart);
+        }
+    }
+    else {
+        // Fit domain is 1..n; a forecast of k periods extends it to 1−k / n+k.
+        const xStart = 1 - backward;
+        const xEnd = values.length + forward;
+        for (let x = xStart; x <= xEnd; x++)
+            xs.push(x);
+    }
     let predict = null;
     let equation = null;
     switch (type) {
@@ -263,9 +315,10 @@ export const computeTrendline = (values, spec = {}) => {
         default:
             return null;
     }
-    // Report the renderer-facing 0-based category index (see module comment).
+    // Report the renderer-facing 0-based category index (see module comment);
+    // an XY fit reports the real X it was sampled at.
     const points = xs
-        .map((x) => ({ x: x - 1, y: predict(x) }))
+        .map((x) => ({ x: xValues ? x : x - 1, y: predict(x) }))
         .filter((p) => Number.isFinite(p.y));
     if (points.length < 2)
         return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rowsncolumns/charts",
-  "version": "28.1.7",
+  "version": "28.1.10",
   "author": "Vinay M",
   "license": "SEE LICENSE IN LICENSE.md",
   "main": "./dist/cjs/index.js",
@@ -70,9 +70,9 @@
     "@rowsncolumns/common-types": ">=5.3.2",
     "@rowsncolumns/grid": ">=13.2.35",
     "@rowsncolumns/icons": ">=7.2.33",
-    "@rowsncolumns/spreadsheet": ">=10.4.6",
-    "@rowsncolumns/spreadsheet-state": ">=29.1.7",
-    "@rowsncolumns/toolkit": ">=24.5.8",
+    "@rowsncolumns/spreadsheet": ">=10.4.8",
+    "@rowsncolumns/spreadsheet-state": ">=29.1.8",
+    "@rowsncolumns/toolkit": ">=24.5.10",
     "@rowsncolumns/ui": ">=16.0.4",
     "@rowsncolumns/utils": ">=9.5.5",
     "@types/react-plotly.js": "^2.6.3",