@rowsncolumns/charts 27.0.30

package/dist/cjs/utils/echarts-gl-loader.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__resetEchartsGlLoaderForTests = exports.loadEchartsGl = exports.getEchartsGlState = void 0;
+var tslib_1 = require("tslib");
+/**
+ * Lazy loader for echarts-gl.
+ *
+ * echarts-gl (plus its claygl dependency) is a large chunk that only 3-D /
+ * surface specs need, so it is NEVER imported eagerly — the renderer calls
+ * `loadEchartsGl()` the first time a 3-D spec is actually about to render,
+ * draws the 2-D fallback immediately, and upgrades to 3-D when the module
+ * resolves. A failed import latches the "failed" state so the renderer
+ * keeps the 2-D fallback without retrying on every update.
+ */
+var components_1 = require("echarts/components");
+var echarts = tslib_1.__importStar(require("echarts/core"));
+var state = "unloaded";
+var loadPromise = null;
+var getEchartsGlState = function () { return state; };
+exports.getEchartsGlState = getEchartsGlState;
+/**
+ * Kick off (or join) the echarts-gl dynamic import and register the 3-D
+ * charts/components the renderer uses. Resolves true when 3-D rendering is
+ * available, false when the import failed (renderer keeps the 2-D fallback).
+ */
+var loadEchartsGl = function () {
+    if (!loadPromise) {
+        state = "loading";
+        loadPromise = Promise.all([
+            Promise.resolve().then(function () { return tslib_1.__importStar(require("echarts-gl/charts")); }),
+            Promise.resolve().then(function () { return tslib_1.__importStar(require("echarts-gl/components")); }),
+        ])
+            .then(function (_a) {
+            var _b = tslib_1.__read(_a, 2), glCharts = _b[0], glComponents = _b[1];
+            echarts.use([
+                glCharts.Bar3DChart,
+                glCharts.Line3DChart,
+                glCharts.SurfaceChart,
+                glComponents.Grid3DComponent,
+                // Surface plots color their z-heights through a visualMap ramp.
+                components_1.VisualMapComponent,
+            ]);
+            state = "ready";
+            return true;
+        })
+            .catch(function () {
+            state = "failed";
+            return false;
+        });
+    }
+    return loadPromise;
+};
+exports.loadEchartsGl = loadEchartsGl;
+/** Test hook — resets the module-level load state. */
+var __resetEchartsGlLoaderForTests = function () {
+    state = "unloaded";
+    loadPromise = null;
+};
+exports.__resetEchartsGlLoaderForTests = __resetEchartsGlLoaderForTests;

package/dist/cjs/utils/error-bars.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Error-bar magnitudes shared by chart renderers.
+ *
+ * Mirrors OOXML `<c:errBars>`. Given a series' numeric values and an
+ * error-bar spec, this returns the +/- magnitude for each data point so
+ * the renderer can draw whiskers. Both echarts (via a custom series) and
+ * plotly (via native `error_y`/`error_x`) consume the same arrays.
+ *
+ * Supported valueTypes: fixedVal, percentage, stdDev, stdErr, custom.
+ * `custom` (Excel `errValType="cust"`) reads per-point plus/minus
+ * magnitudes from `plusValues` / `minusValues` — resolved from the
+ * spec's `plusRange` / `minusRange` worksheet ranges via
+ * `resolveCustomErrorBarValues` before this runs.
+ */
+export type ErrorBarValueType = "fixedVal" | "percentage" | "stdDev" | "stdErr" | "custom";
+export type ErrorBarSpecInput = {
+    valueType?: ErrorBarValueType | null;
+    value?: number | null;
+    barType?: "both" | "plus" | "minus" | null;
+    /**
+     * Custom only — per-point upward magnitudes, index-aligned with the
+     * series values. Missing/non-finite entries draw no upper whisker.
+     */
+    plusValues?: (number | null | undefined)[] | null;
+    /** Custom only — per-point downward magnitudes. */
+    minusValues?: (number | null | undefined)[] | null;
+};
+export type ErrorBarMagnitudes = {
+    /** Upward magnitude per point (>= 0). */
+    plus: number[];
+    /** Downward magnitude per point (>= 0). */
+    minus: number[];
+};
+/**
+ * Resolve a custom error-bar spec's `plusRange` / `minusRange` into the
+ * `plusValues` / `minusValues` arrays `computeErrorBars` consumes.
+ *
+ * Range resolution is injected so this stays renderer-agnostic — both
+ * chart renderers pass the same `getSeriesValuesFromRange` extractor
+ * they already use for series data. Non-custom specs pass through
+ * untouched. Cells that don't hold finite numbers resolve to null
+ * (zero magnitude), keeping the arrays index-aligned with the range.
+ */
+export declare const resolveCustomErrorBarValues: <TRange>(spec: (ErrorBarSpecInput & {
+    plusRange?: TRange | null;
+    minusRange?: TRange | null;
+}) | null | undefined, getValuesFromRange: (range: TRange) => unknown[] | null | undefined) => ErrorBarSpecInput | null | undefined;
+/**
+ * Compute per-point error-bar magnitudes for a series.
+ *
+ * @param values    Raw series y-values (non-finite entries become 0
+ *                  magnitude so the arrays stay index-aligned).
+ * @param spec      The parsed error-bar spec.
+ * @returns         Plus/minus magnitude arrays, or null when the spec is
+ *                  undrawable (zero magnitude, or custom without values).
+ */
+export declare const computeErrorBars: (values: (number | null | undefined)[], spec: ErrorBarSpecInput | null | undefined) => ErrorBarMagnitudes | null;
+//# sourceMappingURL=error-bars.d.ts.map

package/dist/cjs/utils/error-bars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-bars.d.ts","sourceRoot":"","sources":["../../../utils/error-bars.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,iBAAiB,GACzB,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,QAAQ,CAAC;AAEb,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACrC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IAC3C;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,GAAG,IAAI,CAAC;IAClD,mDAAmD;IACnD,WAAW,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,GAAG,IAAI,CAAC;CACpD,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,yCAAyC;IACzC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,2CAA2C;IAC3C,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAoBF;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B,GAAI,MAAM,EAChD,MACI,CAAC,iBAAiB,GAAG;IACnB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,CAAC,GACF,IAAI,GACJ,SAAS,EACb,oBAAoB,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,KAClE,iBAAiB,GAAG,IAAI,GAAG,SAgB7B,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACrC,MAAM,iBAAiB,GAAG,IAAI,GAAG,SAAS,KACzC,kBAAkB,GAAG,IAsEvB,CAAC"}

package/dist/cjs/utils/error-bars.js

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * Error-bar magnitudes shared by chart renderers.
+ *
+ * Mirrors OOXML `<c:errBars>`. Given a series' numeric values and an
+ * error-bar spec, this returns the +/- magnitude for each data point so
+ * the renderer can draw whiskers. Both echarts (via a custom series) and
+ * plotly (via native `error_y`/`error_x`) consume the same arrays.
+ *
+ * Supported valueTypes: fixedVal, percentage, stdDev, stdErr, custom.
+ * `custom` (Excel `errValType="cust"`) reads per-point plus/minus
+ * magnitudes from `plusValues` / `minusValues` — resolved from the
+ * spec's `plusRange` / `minusRange` worksheet ranges via
+ * `resolveCustomErrorBarValues` before this runs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeErrorBars = exports.resolveCustomErrorBarValues = void 0;
+var tslib_1 = require("tslib");
+var isFiniteNum = function (v) {
+    return typeof v === "number" && Number.isFinite(v);
+};
+var mean = function (nums) {
+    return nums.length === 0 ? 0 : nums.reduce(function (s, n) { return s + n; }, 0) / nums.length;
+};
+/**
+ * Population-style standard deviation (divides by N), matching Excel's
+ * STDEVP, which is what chart stdDev error bars use.
+ */
+var stdDev = function (nums) {
+    if (nums.length === 0)
+        return 0;
+    var m = mean(nums);
+    var variance = nums.reduce(function (s, n) { return s + Math.pow((n - m), 2); }, 0) / nums.length;
+    return Math.sqrt(variance);
+};
+/**
+ * Resolve a custom error-bar spec's `plusRange` / `minusRange` into the
+ * `plusValues` / `minusValues` arrays `computeErrorBars` consumes.
+ *
+ * Range resolution is injected so this stays renderer-agnostic — both
+ * chart renderers pass the same `getSeriesValuesFromRange` extractor
+ * they already use for series data. Non-custom specs pass through
+ * untouched. Cells that don't hold finite numbers resolve to null
+ * (zero magnitude), keeping the arrays index-aligned with the range.
+ */
+var resolveCustomErrorBarValues = function (spec, getValuesFromRange) {
+    var _a, _b;
+    if (!spec || spec.valueType !== "custom")
+        return spec;
+    var resolve = function (range) {
+        var _a;
+        if (!range)
+            return undefined;
+        return ((_a = getValuesFromRange(range)) !== null && _a !== void 0 ? _a : []).map(function (raw) {
+            var n = typeof raw === "string" ? Number(raw) : raw;
+            return isFiniteNum(n) ? n : null;
+        });
+    };
+    return tslib_1.__assign(tslib_1.__assign({}, spec), { plusValues: (_a = spec.plusValues) !== null && _a !== void 0 ? _a : resolve(spec.plusRange), minusValues: (_b = spec.minusValues) !== null && _b !== void 0 ? _b : resolve(spec.minusRange) });
+};
+exports.resolveCustomErrorBarValues = resolveCustomErrorBarValues;
+/**
+ * Compute per-point error-bar magnitudes for a series.
+ *
+ * @param values    Raw series y-values (non-finite entries become 0
+ *                  magnitude so the arrays stay index-aligned).
+ * @param spec      The parsed error-bar spec.
+ * @returns         Plus/minus magnitude arrays, or null when the spec is
+ *                  undrawable (zero magnitude, or custom without values).
+ */
+var computeErrorBars = function (values, spec) {
+    var e_1, _a;
+    var _b, _c;
+    if (!spec)
+        return null;
+    var valueType = (_b = spec.valueType) !== null && _b !== void 0 ? _b : "fixedVal";
+    var barType = (_c = spec.barType) !== null && _c !== void 0 ? _c : "both";
+    // `custom` — asymmetric per-point magnitudes read from the resolved
+    // plus/minus ranges. Arrays are index-aligned with `values`; entries
+    // beyond a range's length (or non-finite ones) get 0 magnitude.
+    if (valueType === "custom") {
+        var plusSource_1 = barType === "minus" ? null : spec.plusValues;
+        var minusSource_1 = barType === "plus" ? null : spec.minusValues;
+        var plus_1 = values.map(function (_, i) {
+            var v = plusSource_1 === null || plusSource_1 === void 0 ? void 0 : plusSource_1[i];
+            return isFiniteNum(v) ? Math.abs(v) : 0;
+        });
+        var minus_1 = values.map(function (_, i) {
+            var v = minusSource_1 === null || minusSource_1 === void 0 ? void 0 : minusSource_1[i];
+            return isFiniteNum(v) ? Math.abs(v) : 0;
+        });
+        if (plus_1.every(function (v) { return v === 0; }) && minus_1.every(function (v) { return v === 0; })) {
+            return null;
+        }
+        return { plus: plus_1, minus: minus_1 };
+    }
+    var numeric = values.filter(isFiniteNum);
+    var magnitudeFor;
+    switch (valueType) {
+        case "fixedVal": {
+            var v_1 = isFiniteNum(spec.value) ? Math.abs(spec.value) : 0;
+            if (v_1 === 0)
+                return null;
+            magnitudeFor = function () { return v_1; };
+            break;
+        }
+        case "percentage": {
+            var pct_1 = isFiniteNum(spec.value) ? Math.abs(spec.value) : 0;
+            if (pct_1 === 0)
+                return null;
+            magnitudeFor = function (v) { return Math.abs(v) * (pct_1 / 100); };
+            break;
+        }
+        case "stdDev": {
+            var multiplier = isFiniteNum(spec.value) ? Math.abs(spec.value) : 1;
+            var sd = stdDev(numeric);
+            if (sd === 0)
+                return null;
+            var mag_1 = sd * multiplier;
+            magnitudeFor = function () { return mag_1; };
+            break;
+        }
+        case "stdErr": {
+            var sd = stdDev(numeric);
+            if (sd === 0 || numeric.length === 0)
+                return null;
+            var se_1 = sd / Math.sqrt(numeric.length);
+            magnitudeFor = function () { return se_1; };
+            break;
+        }
+        default:
+            return null;
+    }
+    var plus = [];
+    var minus = [];
+    try {
+        for (var values_1 = tslib_1.__values(values), values_1_1 = values_1.next(); !values_1_1.done; values_1_1 = values_1.next()) {
+            var raw = values_1_1.value;
+            var v = isFiniteNum(raw) ? raw : 0;
+            var mag = magnitudeFor(v);
+            plus.push(barType === "minus" ? 0 : mag);
+            minus.push(barType === "plus" ? 0 : mag);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (values_1_1 && !values_1_1.done && (_a = values_1.return)) _a.call(values_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return { plus: plus, minus: minus };
+};
+exports.computeErrorBars = computeErrorBars;

package/dist/cjs/utils/gradient.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Series gradient-fill helpers shared by chart renderers.
+ *
+ * Mirrors OOXML `<a:gradFill>` carried on a series via
+ * `ChartData.gradient`. A linear gradient has a `degree` rotation and a
+ * list of color stops; a `path` gradient is radial-ish with inset axes.
+ *
+ * echarts: paints faithfully via `echarts.graphic.LinearGradient`. We
+ *   produce the constructor args (x, y, x2, y2, colorStops) so the
+ *   renderer can `new echarts.graphic.LinearGradient(...)`.
+ *
+ * plotly: has NO faithful per-trace gradient fill for bar/line series.
+ *   We degrade to a representative solid color (the middle stop) so the
+ *   series still reads as "the gradient color". Documented as
+ *   lower-fidelity.
+ */
+export type GradientSpec = {
+    type: "linear" | "path";
+    degree?: number | null;
+    left?: number | null;
+    right?: number | null;
+    top?: number | null;
+    bottom?: number | null;
+    stops: Array<{
+        position: number;
+        color: string;
+    }>;
+};
+export type EchartsLinearGradientArgs = {
+    x: number;
+    y: number;
+    x2: number;
+    y2: number;
+    colorStops: Array<{
+        offset: number;
+        color: string;
+    }>;
+};
+/**
+ * Build the args for `new echarts.graphic.LinearGradient(x, y, x2, y2,
+ * colorStops)`. Returns null when there are no usable stops. A `path`
+ * gradient is approximated as a linear gradient (echarts core has no
+ * radial graphic for series fills).
+ */
+export declare const gradientToEcharts: (gradient: GradientSpec | null | undefined) => EchartsLinearGradientArgs | null;
+/**
+ * Plotly fallback: there is no per-trace gradient, so pick a single
+ * representative color (the median stop). Returns undefined when no
+ * usable stops exist.
+ */
+export declare const gradientToPlotly: (gradient: GradientSpec | null | undefined) => string | undefined;
+//# sourceMappingURL=gradient.d.ts.map

package/dist/cjs/utils/gradient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradient.d.ts","sourceRoot":"","sources":["../../../utils/gradient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACnD,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACtD,CAAC;AA0CF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,UAAU,YAAY,GAAG,IAAI,GAAG,SAAS,KACxC,yBAAyB,GAAG,IAY9B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAC3B,UAAU,YAAY,GAAG,IAAI,GAAG,SAAS,KACxC,MAAM,GAAG,SAMX,CAAC"}

package/dist/cjs/utils/gradient.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Series gradient-fill helpers shared by chart renderers.
+ *
+ * Mirrors OOXML `<a:gradFill>` carried on a series via
+ * `ChartData.gradient`. A linear gradient has a `degree` rotation and a
+ * list of color stops; a `path` gradient is radial-ish with inset axes.
+ *
+ * echarts: paints faithfully via `echarts.graphic.LinearGradient`. We
+ *   produce the constructor args (x, y, x2, y2, colorStops) so the
+ *   renderer can `new echarts.graphic.LinearGradient(...)`.
+ *
+ * plotly: has NO faithful per-trace gradient fill for bar/line series.
+ *   We degrade to a representative solid color (the middle stop) so the
+ *   series still reads as "the gradient color". Documented as
+ *   lower-fidelity.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gradientToPlotly = exports.gradientToEcharts = void 0;
+/**
+ * Normalize + sort stops to echarts' `{ offset, color }` shape. Positions
+ * are clamped to 0..1; offsets <0 or >1 are not allowed by echarts.
+ */
+var toColorStops = function (stops) {
+    return (stops !== null && stops !== void 0 ? stops : [])
+        .filter(function (s) { return s && typeof s.color === "string"; })
+        .map(function (s) {
+        var _a;
+        return ({
+            offset: Math.max(0, Math.min(1, (_a = s.position) !== null && _a !== void 0 ? _a : 0)),
+            color: s.color,
+        });
+    })
+        .sort(function (a, b) { return a.offset - b.offset; });
+};
+/**
+ * Convert a gradient `degree` (clockwise from the +x axis, OOXML uses
+ * 60000ths of a degree but the parser already normalizes to plain
+ * degrees) into echarts' (x, y) -> (x2, y2) endpoints inside the unit
+ * box. 0° = left→right, 90° = top→bottom.
+ */
+var degreeToEndpoints = function (degree) {
+    var rad = (degree * Math.PI) / 180;
+    // Direction vector of the gradient axis.
+    var dx = Math.cos(rad);
+    var dy = Math.sin(rad);
+    // Project the direction through the centre of the unit box so the ramp
+    // is axis-aligned for the cardinal angles (0° = left→right, 90° =
+    // top→bottom) and points sensibly for everything in between.
+    return {
+        x: 0.5 - dx / 2,
+        y: 0.5 - dy / 2,
+        x2: 0.5 + dx / 2,
+        y2: 0.5 + dy / 2,
+    };
+};
+/**
+ * Build the args for `new echarts.graphic.LinearGradient(x, y, x2, y2,
+ * colorStops)`. Returns null when there are no usable stops. A `path`
+ * gradient is approximated as a linear gradient (echarts core has no
+ * radial graphic for series fills).
+ */
+var gradientToEcharts = function (gradient) {
+    var _a;
+    if (!gradient)
+        return null;
+    var colorStops = toColorStops(gradient.stops);
+    if (colorStops.length < 1)
+        return null;
+    // A single stop is a solid color; still emit a valid gradient (two
+    // identical stops) so callers have a uniform return type.
+    var stops = colorStops.length === 1
+        ? [colorStops[0], { offset: 1, color: colorStops[0].color }]
+        : colorStops;
+    var _b = degreeToEndpoints((_a = gradient.degree) !== null && _a !== void 0 ? _a : 90), x = _b.x, y = _b.y, x2 = _b.x2, y2 = _b.y2;
+    return { x: x, y: y, x2: x2, y2: y2, colorStops: stops };
+};
+exports.gradientToEcharts = gradientToEcharts;
+/**
+ * Plotly fallback: there is no per-trace gradient, so pick a single
+ * representative color (the median stop). Returns undefined when no
+ * usable stops exist.
+ */
+var gradientToPlotly = function (gradient) {
+    if (!gradient)
+        return undefined;
+    var stops = toColorStops(gradient.stops);
+    if (stops.length === 0)
+        return undefined;
+    // Median stop is the most "representative" of the ramp.
+    return stops[Math.floor(stops.length / 2)].color;
+};
+exports.gradientToPlotly = gradientToPlotly;

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

@@ -0,0 +1,28 @@
+import type { ChartSpec, SheetRange, TreemapChart } from "@rowsncolumns/spreadsheet";
+type Extractor = (range: SheetRange, hiddenStrategy?: ChartSpec["hiddenDimensionStrategy"]) => (string | number | boolean | null | undefined)[];
+export type HierarchyRow = {
+    label: string;
+    parent: string | null;
+    value: number | null;
+};
+export type HierarchyNode = {
+    name: string;
+    id?: string;
+    value?: number | null;
+    children?: HierarchyNode[];
+};
+type ExtractOptions = {
+    getDomainValuesFromRange: Extractor;
+    getSeriesValuesFromRange: Extractor;
+    hiddenDimensionStrategy?: ChartSpec["hiddenDimensionStrategy"];
+};
+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[]) => {
+    labels: string[];
+    parents: string[];
+    values: number[];
+};
+export {};
+//# sourceMappingURL=hierarchy.d.ts.map

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

@@ -0,0 +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"}

package/dist/cjs/utils/hierarchy.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPlotlyHierarchy = exports.buildHierarchyTree = exports.extractHierarchyRows = exports.getHierarchyHeaderTitle = void 0;
+var tslib_1 = require("tslib");
+var flattenChartData = function (chartData, extractor, hiddenStrategy, skipFirstRow) {
+    if (skipFirstRow === void 0) { skipFirstRow = false; }
+    if (!chartData || chartData.length === 0)
+        return [];
+    var values = [];
+    chartData.forEach(function (entry) {
+        entry.sources.forEach(function (source) {
+            var _a;
+            var extracted = (_a = extractor(source, hiddenStrategy)) !== null && _a !== void 0 ? _a : [];
+            var trimmed = skipFirstRow && extracted.length > 0 ? extracted.slice(1) : extracted;
+            values.push.apply(values, tslib_1.__spreadArray([], tslib_1.__read(trimmed), false));
+        });
+    });
+    return values;
+};
+var toLabelString = function (value) {
+    if (value === null || value === undefined)
+        return "";
+    return "".concat(value).trim();
+};
+var toParentLabel = function (value) {
+    var label = toLabelString(value);
+    return label === "" ? null : label;
+};
+var toNumericValue = function (value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string") {
+        var parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    if (typeof value === "boolean") {
+        return value ? 1 : 0;
+    }
+    return null;
+};
+var getHierarchyHeaderTitle = function (spec, options) {
+    var e_1, _a, e_2, _b;
+    var _c, _d, _e;
+    if (spec.useFirstRowAsHeaders === false)
+        return undefined;
+    var getDomainValuesFromRange = options.getDomainValuesFromRange;
+    try {
+        for (var _f = tslib_1.__values((_c = spec.parentLabels) !== null && _c !== void 0 ? _c : []), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var entry = _g.value;
+            try {
+                for (var _h = (e_2 = void 0, tslib_1.__values((_d = entry.sources) !== null && _d !== void 0 ? _d : [])), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    var source = _j.value;
+                    var values = (_e = getDomainValuesFromRange(source, options.hiddenDimensionStrategy)) !== null && _e !== void 0 ? _e : [];
+                    if (values.length > 0) {
+                        var header = toLabelString(values[0]);
+                        if (header) {
+                            return header;
+                        }
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return undefined;
+};
+exports.getHierarchyHeaderTitle = getHierarchyHeaderTitle;
+var extractHierarchyRows = function (spec, options) {
+    var getDomainValuesFromRange = options.getDomainValuesFromRange, getSeriesValuesFromRange = options.getSeriesValuesFromRange;
+    var hiddenStrategy = options.hiddenDimensionStrategy;
+    var skipHeaders = spec.useFirstRowAsHeaders !== false;
+    var labels = flattenChartData(spec.labels, getDomainValuesFromRange, hiddenStrategy, skipHeaders).map(toLabelString);
+    var parents = flattenChartData(spec.parentLabels, getDomainValuesFromRange, hiddenStrategy, skipHeaders);
+    var sizes = flattenChartData(spec.sizeData, getSeriesValuesFromRange, hiddenStrategy, skipHeaders);
+    var rows = [];
+    var seenLabels = new Set();
+    for (var i = 0; i < labels.length; i++) {
+        var label = labels[i];
+        if (!label)
+            continue;
+        if (seenLabels.has(label)) {
+            throw new Error("Duplicate hierarchy label detected: ".concat(label));
+        }
+        seenLabels.add(label);
+        rows.push({
+            label: label,
+            parent: toParentLabel(parents[i]),
+            value: toNumericValue(sizes[i]),
+        });
+    }
+    return rows;
+};
+exports.extractHierarchyRows = extractHierarchyRows;
+var getOrCreateNode = function (nodes, name) {
+    var existing = nodes.get(name);
+    if (existing)
+        return existing;
+    var node = {
+        name: name,
+        value: 0,
+        parent: null,
+        children: new Set(),
+    };
+    nodes.set(name, node);
+    return node;
+};
+var buildHierarchyTree = function (rows) {
+    var nodes = new Map();
+    rows.forEach(function (row) {
+        var _a;
+        if (!row.label)
+            return;
+        var labelNode = getOrCreateNode(nodes, row.label);
+        var numericValue = (_a = row.value) !== null && _a !== void 0 ? _a : 0;
+        labelNode.value += numericValue;
+        var parentName = row.parent && row.parent !== row.label ? row.parent : null;
+        if (parentName) {
+            var parentNode = getOrCreateNode(nodes, parentName);
+            parentNode.children.add(row.label);
+            if (labelNode.parent == null) {
+                labelNode.parent = parentName;
+            }
+        }
+    });
+    var buildNode = function (internal) {
+        var children = internal.children.size > 0
+            ? Array.from(internal.children).map(function (childName) {
+                return buildNode(getOrCreateNode(nodes, childName));
+            })
+            : undefined;
+        var value = children && children.length > 0
+            ? children.reduce(function (sum, child) { var _a; return sum + ((_a = child.value) !== null && _a !== void 0 ? _a : 0); }, 0)
+            : internal.value;
+        var node = {
+            name: internal.name,
+            id: internal.name,
+            value: value,
+        };
+        if (children && children.length > 0) {
+            node.children = children;
+        }
+        return node;
+    };
+    var roots = [];
+    nodes.forEach(function (internal) {
+        if (internal.parent == null) {
+            roots.push(buildNode(internal));
+        }
+    });
+    return roots;
+};
+exports.buildHierarchyTree = buildHierarchyTree;
+var toPlotlyHierarchy = function (rows) {
+    var tree = (0, exports.buildHierarchyTree)(rows);
+    var labels = [];
+    var parents = [];
+    var values = [];
+    var traverse = function (nodes, parentName) {
+        nodes.forEach(function (node) {
+            var _a;
+            labels.push(node.name);
+            parents.push(parentName !== null && parentName !== void 0 ? parentName : "");
+            values.push((_a = node.value) !== null && _a !== void 0 ? _a : 0);
+            if (node.children) {
+                traverse(node.children, node.name);
+            }
+        });
+    };
+    traverse(tree, null);
+    return { labels: labels, parents: parents, values: values };
+};
+exports.toPlotlyHierarchy = toPlotlyHierarchy;