@rowsncolumns/charts 28.1.8 → 28.1.11

package/dist/esm/utils/bubble.js

@@ -12,22 +12,45 @@ export const toNumericValue = (value) => {
     }
     return null;
 };
-export const createBubbleSizeScale = (values) => {
+/** The largest bubble's diameter at bubbleScale 100: a quarter of the plot area's smaller side. */
+export const BUBBLE_MAX_DIAMETER_FRACTION = 0.25;
+/** Fallback plot side when the chart has no measured size yet. */
+const DEFAULT_PLOT_MIN_SIDE = 240;
+/** A positive size never collapses below this diameter. */
+const MIN_BUBBLE_DIAMETER = 2;
+/**
+ * Pixel diameter per size value, scaled from ZERO like Excel: the largest
+ * absolute value gets the maximum diameter and every other bubble's area
+ * (or width) is its share of that value. Scaling from the minimum value
+ * instead made the ratio between bubbles depend on the spread of the
+ * data (100 and 101 drew as the smallest and largest bubble), and a
+ * linear diameter made the perceived area grow with the square of the
+ * value (rowsncolumns/spreadsheet#1068).
+ */
+export const createBubbleSizeScale = (values, options = {}) => {
+    const maxDiameter = bubbleMaxDiameter(options);
     const valid = values.filter((value) => Number.isFinite(value));
-    if (valid.length === 0) {
-        return () => 24;
-    }
-    const min = Math.min(...valid);
-    const max = Math.max(...valid);
-    const range = max - min || 1;
+    const maxAbs = valid.reduce((max, value) => Math.max(max, Math.abs(value)), 0);
+    const byWidth = options.sizeRepresents === "width";
     return (value) => {
-        if (!Number.isFinite(value)) {
-            return 24;
+        if (!Number.isFinite(value) || maxAbs === 0) {
+            return maxDiameter;
         }
-        const ratio = (value - min) / range;
-        return 12 + ratio * 42;
+        const share = Math.abs(value) / maxAbs;
+        const diameter = maxDiameter * (byWidth ? share : Math.sqrt(share));
+        return share > 0 ? Math.max(MIN_BUBBLE_DIAMETER, diameter) : 0;
     };
 };
+/** The diameter of the largest bubble for these options. */
+export const bubbleMaxDiameter = (options = {}) => {
+    const plotMinSide = typeof options.plotMinSide === "number" && options.plotMinSide > 0
+        ? options.plotMinSide
+        : DEFAULT_PLOT_MIN_SIDE;
+    const scale = typeof options.bubbleScale === "number" && Number.isFinite(options.bubbleScale)
+        ? Math.min(300, Math.max(0, options.bubbleScale)) / 100
+        : 1;
+    return plotMinSide * BUBBLE_MAX_DIAMETER_FRACTION * scale;
+};
 /**
  * Build the X-coordinate index for a series. Numeric values map to
  * their own coordinate; string values become categorical (deduped into
@@ -107,6 +130,7 @@ export const prepareBubbleSeriesData = ({ xValues, labelValues, sizeValues, seri
                 value: [coordinate.coordinate, y, sizeValue],
                 name: label,
                 xLabel: coordinateLabel,
+                index: i,
             });
         }
         const name = serie.name && serie.name.trim()

package/dist/esm/utils/echarts-overlays.d.ts

@@ -0,0 +1,46 @@
+type OverlaySeriesSpec = {
+    color?: string | null;
+    useSecondaryAxis?: boolean | null;
+    trendlines?: Array<{
+        type?: any;
+        order?: number | null;
+        period?: number | null;
+        name?: string | null;
+        color?: string | null;
+        forecastForward?: number | null;
+        forecastBackward?: number | null;
+    }> | null;
+    errorBars?: {
+        direction?: "x" | "y" | null;
+        barType?: "both" | "plus" | "minus" | null;
+        valueType?: any;
+        value?: number | null;
+        noEndCap?: boolean | null;
+        plusRange?: any;
+        minusRange?: any;
+    } | null;
+};
+export type EchartsOverlayOptions<TRange = unknown> = {
+    series: OverlaySeriesSpec;
+    /** The series' values (Y on an XY chart), index-aligned with `xValues`. */
+    values: (number | null | undefined)[];
+    /**
+     * Scatter / bubble: the real X coordinate per point. Omitted for a
+     * category chart, where the point index is the category coordinate.
+     */
+    xValues?: (number | null | undefined)[] | null;
+    /** Horizontal bar: the category index is the y coordinate. */
+    horizontal?: boolean;
+    dataLabel: string;
+    /** The data series' own colour — overlays default to it. */
+    seriesColor: string;
+    /** Reads a custom error bar's plus / minus range. */
+    resolveRange: (range: TRange) => unknown[] | null | undefined;
+};
+/**
+ * Build the overlay series for one data series. Returns an empty array
+ * when the series has neither trendlines nor error bars.
+ */
+export declare const buildEchartsOverlaySeries: <TRange = unknown>({ series, values, xValues, horizontal, dataLabel, seriesColor, resolveRange, }: EchartsOverlayOptions<TRange>) => any[];
+export {};
+//# sourceMappingURL=echarts-overlays.d.ts.map

package/dist/esm/utils/echarts-overlays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"echarts-overlays.d.ts","sourceRoot":"","sources":["../../../utils/echarts-overlays.ts"],"names":[],"mappings":"AAkBA,KAAK,iBAAiB,GAAG;IACvB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC,UAAU,CAAC,EACP,KAAK,CAAC;QACJ,IAAI,CAAC,EAAE,GAAG,CAAC;QACX,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAChC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAClC,CAAC,GACF,IAAI,CAAC;IACT,SAAS,CAAC,EAAE;QACV,SAAS,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;QAC7B,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;QAC3C,SAAS,CAAC,EAAE,GAAG,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,QAAQ,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;QAC1B,SAAS,CAAC,EAAE,GAAG,CAAC;QAChB,UAAU,CAAC,EAAE,GAAG,CAAC;KAClB,GAAG,IAAI,CAAC;CACV,CAAC;AAEF,MAAM,MAAM,qBAAqB,CAAC,MAAM,GAAG,OAAO,IAAI;IACpD,MAAM,EAAE,iBAAiB,CAAC;IAC1B,2EAA2E;IAC3E,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC;IACtC;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,GAAG,IAAI,CAAC;IAC/C,8DAA8D;IAC9D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAC;IACpB,qDAAqD;IACrD,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;CAC/D,CAAC;AAIF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,GAAI,MAAM,GAAG,OAAO,EAAE,gFAQzD,qBAAqB,CAAC,MAAM,CAAC,KAAG,GAAG,EA4HrC,CAAC"}

package/dist/esm/utils/echarts-overlays.js

@@ -0,0 +1,135 @@
+/**
+ * Trendline and error-bar overlay series for the echarts renderer.
+ *
+ * One data series may carry trendlines (`<c:trendline>`) and error bars
+ * (`<c:errBars>`); both are drawn as extra echarts series appended after
+ * the data series. The same builder serves every cartesian layout:
+ *
+ *   - category charts (line / column / area): the point index is the
+ *     category coordinate, values sit on the value axis;
+ *   - horizontal bars: the same, with the axes swapped — the category
+ *     index is the y coordinate (rowsncolumns/spreadsheet#1061 drew the
+ *     overlays on the swapped axes, outside the plot);
+ *   - scatter / bubble: real (x, y) coordinates per point, and the
+ *     trendline is a regression of Y on X (#1067).
+ */
+import { computeErrorBars, resolveCustomErrorBarValues } from "./error-bars";
+import { computeTrendline } from "./trendline";
+const ERROR_BAR_CAP_HALF = 5;
+/**
+ * Build the overlay series for one data series. Returns an empty array
+ * when the series has neither trendlines nor error bars.
+ */
+export const buildEchartsOverlaySeries = ({ series, values, xValues, horizontal = false, dataLabel, seriesColor, resolveRange, }) => {
+    if (values.length === 0)
+        return [];
+    const overlays = [];
+    const isXY = Array.isArray(xValues);
+    const useSecondary = series.useSecondaryAxis ? { yAxisIndex: 1 } : {};
+    // Trendlines — one overlay line series per spec.
+    for (const tl of series.trendlines ?? []) {
+        const result = computeTrendline(values, {
+            type: tl.type,
+            order: tl.order,
+            period: tl.period,
+            forecastForward: tl.forecastForward,
+            forecastBackward: tl.forecastBackward,
+        }, isXY ? xValues : undefined);
+        if (!result || result.points.length < 2)
+            continue;
+        const tlName = tl.name ??
+            `${dataLabel ? dataLabel + " " : ""}${tl.type ?? "linear"} trend`;
+        overlays.push({
+            type: "line",
+            name: tlName,
+            // On a category chart the index x overlays the category axis even
+            // when forecasting extends beyond the data range; a horizontal bar
+            // keeps its categories on y.
+            data: result.points.map((p) => (horizontal ? [p.y, p.x] : [p.x, p.y])),
+            showSymbol: false,
+            smooth: tl.type === "poly",
+            lineStyle: {
+                color: tl.color ?? seriesColor,
+                type: "dashed",
+                width: 2,
+            },
+            itemStyle: { color: tl.color ?? seriesColor },
+            tooltip: { show: false },
+            z: 5,
+            ...useSecondary,
+        });
+    }
+    // Error bars — a custom series of whiskers. valueType "custom" reads
+    // per-point magnitudes from the spec's plus/minus ranges, resolved
+    // through the same extractor the series values use.
+    if (series.errorBars) {
+        const direction = series.errorBars.direction ?? "y";
+        // An X error bar on an XY chart sizes from the X values (a percentage
+        // or deviation of X); a category chart has only value-axis bars, so a
+        // horizontal bar's whisker runs along x whatever the direction says.
+        const alongX = isXY ? direction === "x" : horizontal || direction === "x";
+        const magnitudeSource = isXY && alongX ? xValues : values;
+        const magnitudes = computeErrorBars(magnitudeSource, resolveCustomErrorBarValues(series.errorBars, resolveRange));
+        if (magnitudes) {
+            const noEndCap = series.errorBars.noEndCap ?? false;
+            const errorData = [];
+            for (let i = 0; i < values.length; i++) {
+                const v = values[i];
+                const y = typeof v === "number" && Number.isFinite(v) ? v : null;
+                const x = isXY ? xValues?.[i] : i;
+                if (y === null || typeof x !== "number" || !Number.isFinite(x)) {
+                    continue;
+                }
+                // [a, b] is the point's (x, y) data coordinate; a horizontal bar
+                // keeps its value on x and its category on y.
+                const [a, b] = !isXY && horizontal ? [y, x] : [x, y];
+                errorData.push([a, b, magnitudes.plus[i] ?? 0, magnitudes.minus[i] ?? 0]);
+            }
+            overlays.push({
+                type: "custom",
+                name: `${dataLabel ? dataLabel + " " : ""}error`,
+                data: errorData,
+                z: 6,
+                tooltip: { show: false },
+                ...useSecondary,
+                renderItem: (_params, api) => {
+                    const a = api.value(0);
+                    const b = api.value(1);
+                    const plus = api.value(2);
+                    const minus = api.value(3);
+                    const center = api.coord([a, b]);
+                    const hi = alongX ? api.coord([a + plus, b]) : api.coord([a, b + plus]);
+                    const lo = alongX ? api.coord([a - minus, b]) : api.coord([a, b - minus]);
+                    const stroke = { stroke: seriesColor, lineWidth: 1 };
+                    const children = [
+                        {
+                            type: "line",
+                            shape: alongX
+                                ? { x1: lo[0], y1: center[1], x2: hi[0], y2: center[1] }
+                                : { x1: center[0], y1: lo[1], x2: center[0], y2: hi[1] },
+                            style: stroke,
+                        },
+                    ];
+                    if (!noEndCap) {
+                        const cap = ERROR_BAR_CAP_HALF;
+                        children.push({
+                            type: "line",
+                            shape: alongX
+                                ? { x1: hi[0], y1: center[1] - cap, x2: hi[0], y2: center[1] + cap }
+                                : { x1: center[0] - cap, y1: hi[1], x2: center[0] + cap, y2: hi[1] },
+                            style: stroke,
+                        }, {
+                            type: "line",
+                            shape: alongX
+                                ? { x1: lo[0], y1: center[1] - cap, x2: lo[0], y2: center[1] + cap }
+                                : { x1: center[0] - cap, y1: lo[1], x2: center[0] + cap, y2: lo[1] },
+                            style: stroke,
+                        });
+                    }
+                    return { type: "group", children };
+                },
+            });
+        }
+    }
+    return overlays;
+};

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

@@ -1,12 +1,21 @@
 import type { ChartSpec, SheetRange, TreemapChart } from "@rowsncolumns/spreadsheet";
 type Extractor = (range: SheetRange, hiddenStrategy?: ChartSpec["hiddenDimensionStrategy"]) => (string | number | boolean | null | undefined)[];
 export type HierarchyRow = {
+    /** The node this row defines — the innermost filled level cell. */
     label: string;
+    /** The immediate parent (the last entry of `path`), null for a root. */
     parent: string | null;
     value: number | null;
+    /**
+     * The level names above the node, top level first, after Excel's
+     * fill-down of blank level cells. Absent on a legacy adjacency row
+     * (`parent` alone, naming another row's label).
+     */
+    path?: string[];
 };
 export type HierarchyNode = {
     name: string;
+    /** Unique within the tree: the node's path joined with "/". */
     id?: string;
     value?: number | null;
     children?: HierarchyNode[];
@@ -19,10 +28,23 @@ type ExtractOptions = {
 export declare const getHierarchyHeaderTitle: (spec: TreemapChart, options: ExtractOptions) => string | undefined;
 export declare const extractHierarchyRows: (spec: TreemapChart, options: ExtractOptions) => HierarchyRow[];
 export declare const buildHierarchyTree: (rows: HierarchyRow[]) => HierarchyNode[];
-export declare const toPlotlyHierarchy: (rows: HierarchyRow[]) => {
+export type PlotlyHierarchy = {
+    /** Node names, as drawn. */
     labels: string[];
+    /** Unique node ids (the path joined with "/"); `parents` reference these. */
+    ids: string[];
+    /** Parent id per node, "" for a root. */
     parents: string[];
     values: number[];
+    /** Depth per node, 0 for a root. */
+    depths: number[];
 };
+export declare const toPlotlyHierarchy: (rows: HierarchyRow[]) => PlotlyHierarchy;
+/**
+ * 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 declare const hierarchyNodeColors: (hierarchy: Pick<PlotlyHierarchy, "ids" | "parents">, palette: string[]) => string[];
 export {};
 //# sourceMappingURL=hierarchy.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hierarchy.d.ts","sourceRoot":"","sources":["../../../utils/hierarchy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,SAAS,EACT,UAAU,EACV,YAAY,EACb,MAAM,2BAA2B,CAAC;AAEnC,KAAK,SAAS,GAAG,CACf,KAAK,EAAE,UAAU,EACjB,cAAc,CAAC,EAAE,SAAS,CAAC,yBAAyB,CAAC,KAClD,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC;AAEtD,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;CAC5B,CAAC;AAEF,KAAK,cAAc,GAAG;IACpB,wBAAwB,EAAE,SAAS,CAAC;IACpC,wBAAwB,EAAE,SAAS,CAAC;IACpC,uBAAuB,CAAC,EAAE,SAAS,CAAC,yBAAyB,CAAC,CAAC;CAChE,CAAC;AA+CF,eAAO,MAAM,uBAAuB,GAClC,MAAM,YAAY,EAClB,SAAS,cAAc,KACtB,MAAM,GAAG,SAgBX,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,MAAM,YAAY,EAClB,SAAS,cAAc,KACtB,YAAY,EAyCd,CAAC;AAyBF,eAAO,MAAM,kBAAkB,GAAI,MAAM,YAAY,EAAE,KAAG,aAAa,EAoDtE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,MAAM,YAAY,EAAE;;;;CAoBrD,CAAC"}
+{"version":3,"file":"hierarchy.d.ts","sourceRoot":"","sources":["../../../utils/hierarchy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,SAAS,EACT,UAAU,EACV,YAAY,EACb,MAAM,2BAA2B,CAAC;AAEnC,KAAK,SAAS,GAAG,CACf,KAAK,EAAE,UAAU,EACjB,cAAc,CAAC,EAAE,SAAS,CAAC,yBAAyB,CAAC,KAClD,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC;AAEtD,MAAM,MAAM,YAAY,GAAG;IACzB,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;CAC5B,CAAC;AAEF,KAAK,cAAc,GAAG;IACpB,wBAAwB,EAAE,SAAS,CAAC;IACpC,wBAAwB,EAAE,SAAS,CAAC;IACpC,uBAAuB,CAAC,EAAE,SAAS,CAAC,yBAAyB,CAAC,CAAC;CAChE,CAAC;AA0CF,eAAO,MAAM,uBAAuB,GAClC,MAAM,YAAY,EAClB,SAAS,cAAc,KACtB,MAAM,GAAG,SAgBX,CAAC;AAyCF,eAAO,MAAM,oBAAoB,GAC/B,MAAM,YAAY,EAClB,SAAS,cAAc,KACtB,YAAY,EAiFd,CAAC;AAiDF,eAAO,MAAM,kBAAkB,GAAI,MAAM,YAAY,EAAE,KAAG,aAAa,EAmDtE,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,4BAA4B;IAC5B,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,6EAA6E;IAC7E,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,yCAAyC;IACzC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,oCAAoC;IACpC,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,MAAM,YAAY,EAAE,KAAG,eAwBxD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC9B,WAAW,IAAI,CAAC,eAAe,EAAE,KAAK,GAAG,SAAS,CAAC,EACnD,SAAS,MAAM,EAAE,KAChB,MAAM,EAYR,CAAC"}

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.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;;;;;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;;;iCA/E0D,GAAG;aA4F7E,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,WAoD7E,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;;;iCAlG0D,GAAG;aA+G7E,CAAC"}

package/dist/esm/utils/overrides.js

@@ -126,13 +126,22 @@ export const dataLabelFormatter = (opts, locale) => (params) => {
     if (opts.showPercent && params.percent !== undefined) {
         parts.push(`${params.percent}%`);
     }
+    // The value shows by default unless another field was asked for instead:
+    // an importer records only the flags that are ON, so `<c:showVal val="0"/>`
+    // + `<c:showBubbleSize val="1"/>` arrives as `{ showBubbleSize: true }` and
+    // must label the bubble with its size alone (#1068 / #1079).
     const showVal = opts.showValue !== false &&
         !opts.showCategoryName &&
         !opts.showPercent &&
-        !opts.showSeriesName
+        !opts.showSeriesName &&
+        !opts.showBubbleSize
         ? 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 +149,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(": ");
 };

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"}