@rowsncolumns/charts 27.0.30

package/dist/cjs/utils/three-d.js

@@ -0,0 +1,191 @@
+"use strict";
+/**
+ * 3-D / surface chart helpers.
+ *
+ * Excel's 3-D chart classes (Bar3D / Line3D / Pie3D / Area3D / Surface /
+ * Surface3D) degrade to a 2-D fallback `chartType` when imported, with the
+ * authored type preserved verbatim on the spec as `sourceChartType`. These
+ * helpers gate the renderer's 3-D pipeline off that token and shape the
+ * category/series value matrix into the data layouts the echarts-gl
+ * `bar3D` / `line3D` / `surface` series expect.
+ *
+ * Everything in this module is pure and independent of echarts-gl so it can
+ * be unit-tested without loading (or even installing a working) WebGL stack.
+ *
+ * Mapping decisions (see also basic-chart.tsx):
+ * - BAR_3D    -> `bar3D`   (x = category, y = series index, z = value)
+ * - LINE_3D   -> `line3D`  (one polyline per series at its series-index depth)
+ * - AREA_3D   -> `line3D`  (echarts-gl has no area3D; the polyline keeps the
+ *                          authored depth layout)
+ * - SURFACE / SURFACE_3D -> `surface` (values grid as z-heights over the
+ *                          categories × series plane)
+ * - PIE_3D    -> null      (echarts-gl has no pie3D; the renderer keeps the
+ *                          existing 2-D pie fallback rather than faking it)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SURFACE_COLOR_RAMP = exports.getValueExtent = exports.buildSurfaceData = exports.buildLine3DSeries = exports.buildBar3DData = exports.getCategoryCount = exports.resolve3DRenderKind = exports.is3DSpec = exports.normalize3DSourceType = void 0;
+var tslib_1 = require("tslib");
+var THREE_D_TOKENS = [
+    "BAR_3D",
+    "LINE_3D",
+    "PIE_3D",
+    "AREA_3D",
+    "SURFACE",
+    "SURFACE_3D",
+];
+var THREE_D_TOKEN_SET = new Set(THREE_D_TOKENS);
+/**
+ * Normalize a raw `sourceChartType` value to one of the known 3-D tokens.
+ * Matching is case-insensitive and whitespace-tolerant; anything else
+ * (including null/undefined) returns null.
+ */
+var normalize3DSourceType = function (sourceChartType) {
+    if (typeof sourceChartType !== "string")
+        return null;
+    var token = sourceChartType.trim().toUpperCase();
+    return THREE_D_TOKEN_SET.has(token) ? token : null;
+};
+exports.normalize3DSourceType = normalize3DSourceType;
+/**
+ * True when the spec was authored as one of the six 3-D / surface chart
+ * classes (its `sourceChartType` is one of the degraded-payload tokens).
+ * Note PIE_3D is included here even though it renders as the 2-D pie —
+ * use `resolve3DRenderKind` to decide whether the 3-D pipeline runs.
+ */
+var is3DSpec = function (spec) { return (0, exports.normalize3DSourceType)(spec === null || spec === void 0 ? void 0 : spec.sourceChartType) !== null; };
+exports.is3DSpec = is3DSpec;
+/**
+ * Map a `sourceChartType` token to the echarts-gl series kind it renders
+ * as, or null when the 3-D pipeline should not run:
+ * - PIE_3D — echarts-gl has no pie3D, so the 2-D pie fallback stays.
+ * - AREA_3D — echarts-gl has no area3D; rendered as line3D.
+ * - non-3-D / unknown tokens.
+ */
+var resolve3DRenderKind = function (sourceChartType) {
+    switch ((0, exports.normalize3DSourceType)(sourceChartType)) {
+        case "BAR_3D":
+            return "bar3D";
+        case "LINE_3D":
+        case "AREA_3D":
+            return "line3D";
+        case "SURFACE":
+        case "SURFACE_3D":
+            return "surface";
+        default:
+            // PIE_3D and non-3-D tokens: keep the 2-D fallback rendering.
+            return null;
+    }
+};
+exports.resolve3DRenderKind = resolve3DRenderKind;
+var isFiniteNumber = function (value) {
+    return typeof value === "number" && Number.isFinite(value);
+};
+/** Number of categories = the longest series' value count. */
+var getCategoryCount = function (series) {
+    return series.reduce(function (max, entry) { return Math.max(max, entry.values.length); }, 0);
+};
+exports.getCategoryCount = getCategoryCount;
+/**
+ * Shape series values into a single bar3D data array: one point per
+ * (category, series) cell — x is the category index, y the series index
+ * (depth row), z the value. Non-finite values are skipped (no bar).
+ */
+var buildBar3DData = function (series) {
+    var points = [];
+    series.forEach(function (entry, seriesIndex) {
+        entry.values.forEach(function (value, categoryIndex) {
+            if (isFiniteNumber(value)) {
+                points.push([categoryIndex, seriesIndex, value]);
+            }
+        });
+    });
+    return points;
+};
+exports.buildBar3DData = buildBar3DData;
+/**
+ * Shape series values into one line3D polyline per series, laid out at the
+ * series' index on the depth (y) axis. Non-finite values are skipped, so
+ * the polyline simply bridges gaps.
+ */
+var buildLine3DSeries = function (series) {
+    return series.map(function (entry, seriesIndex) {
+        var data = [];
+        entry.values.forEach(function (value, categoryIndex) {
+            if (isFiniteNumber(value)) {
+                data.push([categoryIndex, seriesIndex, value]);
+            }
+        });
+        return { name: entry.name, data: data };
+    });
+};
+exports.buildLine3DSeries = buildLine3DSeries;
+/**
+ * Shape series values into a complete surface grid over the categories (x)
+ * × series (y) plane with the values as z-heights. Surfaces require a
+ * complete grid, so ragged series are padded and non-finite values are
+ * flattened to 0. Points are emitted row-major (per series row, categories
+ * in order), the layout echarts-gl's surface parser expects.
+ */
+var buildSurfaceData = function (series) {
+    var categoryCount = (0, exports.getCategoryCount)(series);
+    var points = [];
+    series.forEach(function (entry, seriesIndex) {
+        for (var categoryIndex = 0; categoryIndex < categoryCount; categoryIndex++) {
+            var value = entry.values[categoryIndex];
+            points.push([
+                categoryIndex,
+                seriesIndex,
+                isFiniteNumber(value) ? value : 0,
+            ]);
+        }
+    });
+    return points;
+};
+exports.buildSurfaceData = buildSurfaceData;
+/**
+ * [min, max] of the z values, for the surface visualMap range. Returns
+ * [0, 1] for an empty grid and pads a flat grid (min === max) by 1 so the
+ * visualMap never has a zero-width range.
+ */
+var getValueExtent = function (points) {
+    var e_1, _a;
+    if (points.length === 0)
+        return [0, 1];
+    var min = points[0][2];
+    var max = points[0][2];
+    try {
+        for (var points_1 = tslib_1.__values(points), points_1_1 = points_1.next(); !points_1_1.done; points_1_1 = points_1.next()) {
+            var _b = tslib_1.__read(points_1_1.value, 3), z = _b[2];
+            if (z < min)
+                min = z;
+            if (z > max)
+                max = z;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (points_1_1 && !points_1_1.done && (_a = points_1.return)) _a.call(points_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return [min, max === min ? min + 1 : max];
+};
+exports.getValueExtent = getValueExtent;
+/**
+ * Default z-height color ramp for surface plots (the classic echarts-gl
+ * blue → yellow → red diverging ramp). Used via visualMap.inRange.
+ */
+exports.SURFACE_COLOR_RAMP = [
+    "#313695",
+    "#4575b4",
+    "#74add1",
+    "#abd9e9",
+    "#e0f3f8",
+    "#ffffbf",
+    "#fee090",
+    "#fdae61",
+    "#f46d43",
+    "#d73027",
+    "#a50026",
+];

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

@@ -0,0 +1,41 @@
+/**
+ * Trendline regression shared by chart renderers.
+ *
+ * Excel/OOXML `<c:trendline>` supports linear / polynomial / exponential /
+ * logarithmic / power / moving-average fits. Neither echarts nor plotly
+ * compute these for us (echarts-stat is intentionally NOT a dependency),
+ * so the regressions are hand-rolled here as pure least-squares math and
+ * the renderers draw the returned points as an overlay line series.
+ *
+ * All fits operate on the index domain x = 0, 1, 2, … (one step per
+ * category) which matches how a category-axis chart positions points.
+ * The caller passes the raw y-values; gaps (null/NaN) are skipped during
+ * fitting but the fitted curve is still emitted for every x in range.
+ */
+export type TrendlineType = "linear" | "exp" | "log" | "poly" | "power" | "movingAvg";
+export type TrendlinePoint = {
+    x: number;
+    y: number;
+};
+export type TrendlineResult = {
+    /** Fitted points across the (optionally forecast-extended) domain. */
+    points: TrendlinePoint[];
+    /** Coefficient of determination (R²) of the fit, 0..1. null if N/A. */
+    rSquared: number | null;
+    /** Human-readable equation string, e.g. "y = 1.5x + 2". */
+    equation: string | null;
+};
+/**
+ * Compute a trendline for a series of y-values.
+ *
+ * @param values  Raw y-values; the category index is used as x.
+ * @param spec    Trendline parameters (type/order/period/forecast).
+ */
+export declare const computeTrendline: (values: (number | null | undefined)[], spec?: {
+    type?: TrendlineType | null;
+    order?: number | null;
+    period?: number | null;
+    forecastForward?: number | null;
+    forecastBackward?: number | null;
+}) => TrendlineResult | null;
+//# sourceMappingURL=trendline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trendline.d.ts","sourceRoot":"","sources":["../../../utils/trendline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,aAAa,GACrB,QAAQ,GACR,KAAK,GACL,KAAK,GACL,MAAM,GACN,OAAO,GACP,WAAW,CAAC;AAEhB,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;AA+IF;;;;;GAKG;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,IA6FpB,CAAC"}

package/dist/cjs/utils/trendline.js

@@ -0,0 +1,303 @@
+"use strict";
+/**
+ * Trendline regression shared by chart renderers.
+ *
+ * Excel/OOXML `<c:trendline>` supports linear / polynomial / exponential /
+ * logarithmic / power / moving-average fits. Neither echarts nor plotly
+ * compute these for us (echarts-stat is intentionally NOT a dependency),
+ * so the regressions are hand-rolled here as pure least-squares math and
+ * the renderers draw the returned points as an overlay line series.
+ *
+ * All fits operate on the index domain x = 0, 1, 2, … (one step per
+ * category) which matches how a category-axis chart positions points.
+ * The caller passes the raw y-values; gaps (null/NaN) are skipped during
+ * fitting but the fitted curve is still emitted for every x in range.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeTrendline = void 0;
+var tslib_1 = require("tslib");
+var isFiniteNum = function (v) {
+    return typeof v === "number" && Number.isFinite(v);
+};
+/**
+ * Build (x, y) pairs from raw y-values using the category index as x.
+ * Non-finite y-values are dropped (they cannot be fitted).
+ */
+var toPairs = function (values) {
+    var pairs = [];
+    for (var i = 0; i < values.length; i++) {
+        var y = values[i];
+        if (isFiniteNum(y))
+            pairs.push({ x: i, y: y });
+    }
+    return pairs;
+};
+/** Compute R² between observed y and predicted f(x) over the fit pairs. */
+var rSquaredOf = function (pairs, predict) {
+    var e_1, _a;
+    if (pairs.length < 2)
+        return null;
+    var meanY = pairs.reduce(function (s, p) { return s + p.y; }, 0) / pairs.length;
+    var ssRes = 0;
+    var ssTot = 0;
+    try {
+        for (var pairs_1 = tslib_1.__values(pairs), pairs_1_1 = pairs_1.next(); !pairs_1_1.done; pairs_1_1 = pairs_1.next()) {
+            var p = pairs_1_1.value;
+            var yHat = predict(p.x);
+            if (!Number.isFinite(yHat))
+                return null;
+            ssRes += Math.pow((p.y - yHat), 2);
+            ssTot += Math.pow((p.y - meanY), 2);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (pairs_1_1 && !pairs_1_1.done && (_a = pairs_1.return)) _a.call(pairs_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (ssTot === 0)
+        return null;
+    return 1 - ssRes / ssTot;
+};
+var round = function (n, digits) {
+    if (digits === void 0) { digits = 4; }
+    var f = Math.pow(10, digits);
+    return Math.round(n * f) / f;
+};
+/** Solve a small linear system A·x = b via Gaussian elimination. */
+var solveLinearSystem = function (A, b) {
+    var _a;
+    var n = b.length;
+    // Augmented matrix
+    var m = A.map(function (row, i) { return tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(row), false), [b[i]], false); });
+    for (var col = 0; col < n; col++) {
+        // Partial pivot
+        var pivot = col;
+        for (var r = col + 1; r < n; r++) {
+            if (Math.abs(m[r][col]) > Math.abs(m[pivot][col]))
+                pivot = r;
+        }
+        if (Math.abs(m[pivot][col]) < 1e-12)
+            return null;
+        _a = tslib_1.__read([m[pivot], m[col]], 2), m[col] = _a[0], m[pivot] = _a[1];
+        // Eliminate
+        for (var r = 0; r < n; r++) {
+            if (r === col)
+                continue;
+            var factor = m[r][col] / m[col][col];
+            for (var c = col; c <= n; c++) {
+                m[r][c] -= factor * m[col][c];
+            }
+        }
+    }
+    return m.map(function (row, i) { return row[n] / m[i][i]; });
+};
+/** Linear least squares: y = m·x + b. */
+var fitLinear = function (pairs) {
+    var e_2, _a;
+    var n = pairs.length;
+    if (n < 2)
+        return null;
+    var sx = 0;
+    var sy = 0;
+    var sxx = 0;
+    var sxy = 0;
+    try {
+        for (var pairs_2 = tslib_1.__values(pairs), pairs_2_1 = pairs_2.next(); !pairs_2_1.done; pairs_2_1 = pairs_2.next()) {
+            var p = pairs_2_1.value;
+            sx += p.x;
+            sy += p.y;
+            sxx += p.x * p.x;
+            sxy += p.x * p.y;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (pairs_2_1 && !pairs_2_1.done && (_a = pairs_2.return)) _a.call(pairs_2);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    var denom = n * sxx - sx * sx;
+    if (denom === 0)
+        return null;
+    var m = (n * sxy - sx * sy) / denom;
+    var b = (sy - m * sx) / n;
+    return { m: m, b: b };
+};
+/**
+ * Polynomial least squares of the given order: y = c0 + c1·x + … + ck·x^k.
+ * Returns coefficients [c0, c1, …, ck] or null if singular.
+ */
+var fitPoly = function (pairs, order) {
+    var e_3, _a;
+    var k = Math.max(2, Math.min(6, Math.floor(order)));
+    var n = k + 1;
+    if (pairs.length < n)
+        return null;
+    // Build normal equations: (X^T X) c = X^T y where X has columns x^0..x^k
+    var A = Array.from({ length: n }, function () { return new Array(n).fill(0); });
+    var b = new Array(n).fill(0);
+    try {
+        for (var pairs_3 = tslib_1.__values(pairs), pairs_3_1 = pairs_3.next(); !pairs_3_1.done; pairs_3_1 = pairs_3.next()) {
+            var p = pairs_3_1.value;
+            var powers = [];
+            for (var i = 0; i < 2 * k + 1; i++) {
+                powers.push(i === 0 ? 1 : powers[i - 1] * p.x);
+            }
+            for (var row = 0; row < n; row++) {
+                for (var col = 0; col < n; col++) {
+                    A[row][col] += powers[row + col];
+                }
+                b[row] += powers[row] * p.y;
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (pairs_3_1 && !pairs_3_1.done && (_a = pairs_3.return)) _a.call(pairs_3);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return solveLinearSystem(A, b);
+};
+/** Exponential least squares: y = a·e^(b·x). Requires y > 0. */
+var fitExp = function (pairs) {
+    var positive = pairs.filter(function (p) { return p.y > 0; });
+    if (positive.length < 2)
+        return null;
+    // Linearize: ln(y) = ln(a) + b·x
+    var lin = fitLinear(positive.map(function (p) { return ({ x: p.x, y: Math.log(p.y) }); }));
+    if (!lin)
+        return null;
+    return { a: Math.exp(lin.b), b: lin.m };
+};
+/** Logarithmic least squares: y = a + b·ln(x). Requires x > 0. */
+var fitLog = function (pairs) {
+    var positive = pairs.filter(function (p) { return p.x > 0; });
+    if (positive.length < 2)
+        return null;
+    var lin = fitLinear(positive.map(function (p) { return ({ x: Math.log(p.x), y: p.y }); }));
+    if (!lin)
+        return null;
+    return { a: lin.b, b: lin.m };
+};
+/** Power least squares: y = a·x^b. Requires x > 0 and y > 0. */
+var fitPower = function (pairs) {
+    var positive = pairs.filter(function (p) { return p.x > 0 && p.y > 0; });
+    if (positive.length < 2)
+        return null;
+    var lin = fitLinear(positive.map(function (p) { return ({ x: Math.log(p.x), y: Math.log(p.y) }); }));
+    if (!lin)
+        return null;
+    return { a: Math.exp(lin.b), b: lin.m };
+};
+/**
+ * Compute a trendline for a series of y-values.
+ *
+ * @param values  Raw y-values; the category index is used as x.
+ * @param spec    Trendline parameters (type/order/period/forecast).
+ */
+var computeTrendline = function (values, spec) {
+    var _a, _b, _c, _d, _e;
+    if (spec === void 0) { spec = {}; }
+    var pairs = toPairs(values);
+    if (pairs.length < 2)
+        return null;
+    var type = (_a = spec.type) !== null && _a !== void 0 ? _a : "linear";
+    var forward = Math.max(0, Math.floor((_b = spec.forecastForward) !== null && _b !== void 0 ? _b : 0));
+    var backward = Math.max(0, Math.floor((_c = spec.forecastBackward) !== null && _c !== void 0 ? _c : 0));
+    // Moving average is a smoothing of the observed values, not a fitted
+    // function, so it is handled separately and ignores forecasting.
+    if (type === "movingAvg") {
+        var period = Math.max(2, Math.floor((_d = spec.period) !== null && _d !== void 0 ? _d : 2));
+        var points_1 = [];
+        for (var i = period - 1; i < values.length; i++) {
+            var sum = 0;
+            var count = 0;
+            for (var j = i - period + 1; j <= i; j++) {
+                var v = values[j];
+                if (isFiniteNum(v)) {
+                    sum += v;
+                    count++;
+                }
+            }
+            if (count > 0)
+                points_1.push({ x: i, y: sum / count });
+        }
+        return { points: points_1, rSquared: null, equation: null };
+    }
+    var lastX = values.length - 1;
+    var xStart = -backward;
+    var xEnd = lastX + forward;
+    var xs = [];
+    for (var x = xStart; x <= xEnd; x++)
+        xs.push(x);
+    var predict = null;
+    var equation = null;
+    switch (type) {
+        case "linear": {
+            var fit_1 = fitLinear(pairs);
+            if (!fit_1)
+                return null;
+            predict = function (x) { return fit_1.m * x + fit_1.b; };
+            equation = "y = ".concat(round(fit_1.m), "x + ").concat(round(fit_1.b));
+            break;
+        }
+        case "poly": {
+            var coeffs_1 = fitPoly(pairs, (_e = spec.order) !== null && _e !== void 0 ? _e : 2);
+            if (!coeffs_1)
+                return null;
+            predict = function (x) {
+                return coeffs_1.reduce(function (acc, c, i) { return acc + c * Math.pow(x, i); }, 0);
+            };
+            equation =
+                "y = " +
+                    coeffs_1
+                        .map(function (c, i) { return (i === 0 ? "".concat(round(c)) : "".concat(round(c), "x^").concat(i)); })
+                        .join(" + ");
+            break;
+        }
+        case "exp": {
+            var fit_2 = fitExp(pairs);
+            if (!fit_2)
+                return null;
+            predict = function (x) { return fit_2.a * Math.exp(fit_2.b * x); };
+            equation = "y = ".concat(round(fit_2.a), "e^(").concat(round(fit_2.b), "x)");
+            break;
+        }
+        case "log": {
+            var fit_3 = fitLog(pairs);
+            if (!fit_3)
+                return null;
+            // ln(0) and ln(negative) are undefined; clamp x to >0 for the curve.
+            predict = function (x) { return fit_3.a + fit_3.b * Math.log(x <= 0 ? 1e-9 : x); };
+            equation = "y = ".concat(round(fit_3.a), " + ").concat(round(fit_3.b), "ln(x)");
+            break;
+        }
+        case "power": {
+            var fit_4 = fitPower(pairs);
+            if (!fit_4)
+                return null;
+            predict = function (x) { return fit_4.a * (x <= 0 ? 0 : Math.pow(x, fit_4.b)); };
+            equation = "y = ".concat(round(fit_4.a), "x^").concat(round(fit_4.b));
+            break;
+        }
+        default:
+            return null;
+    }
+    var points = xs
+        .map(function (x) { return ({ x: x, y: predict(x) }); })
+        .filter(function (p) { return Number.isFinite(p.y); });
+    if (points.length < 2)
+        return null;
+    return {
+        points: points,
+        rSquared: rSquaredOf(pairs, predict),
+        equation: equation,
+    };
+};
+exports.computeTrendline = computeTrendline;

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

@@ -0,0 +1,24 @@
+/**
+ * Waterfall computation shared by chart renderers.
+ *
+ * Plotly has a native waterfall trace that takes raw values and computes
+ * the cumulative offsets itself. Echarts has no native waterfall; the
+ * renderer pre-computes two parallel series:
+ *   - placeholder: transparent bars at the cumulative offset, used as
+ *     "spacers" so the visible bar starts at the right baseline.
+ *   - value: the actual bar value (rendered on top of the placeholder).
+ *
+ * Total bars (where `isTotal` is true at that position) reset to baseline.
+ *
+ * `cumulative` is the running total after the bar — the y coordinate of
+ * the Excel-style connector line drawn across to the next bar.
+ */
+export type WaterfallStep = {
+    label: string;
+    placeholder: number;
+    value: number;
+    isTotal: boolean;
+    cumulative: number;
+};
+export declare const computeWaterfall: (values: (number | null | undefined)[], labels: string[], totalIndices?: Set<number>) => WaterfallStep[];
+//# sourceMappingURL=waterfall.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"waterfall.d.ts","sourceRoot":"","sources":["../../../utils/waterfall.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACrC,QAAQ,MAAM,EAAE,EAChB,eAAc,GAAG,CAAC,MAAM,CAAa,KACpC,aAAa,EAsCf,CAAC"}

package/dist/cjs/utils/waterfall.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Waterfall computation shared by chart renderers.
+ *
+ * Plotly has a native waterfall trace that takes raw values and computes
+ * the cumulative offsets itself. Echarts has no native waterfall; the
+ * renderer pre-computes two parallel series:
+ *   - placeholder: transparent bars at the cumulative offset, used as
+ *     "spacers" so the visible bar starts at the right baseline.
+ *   - value: the actual bar value (rendered on top of the placeholder).
+ *
+ * Total bars (where `isTotal` is true at that position) reset to baseline.
+ *
+ * `cumulative` is the running total after the bar — the y coordinate of
+ * the Excel-style connector line drawn across to the next bar.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeWaterfall = void 0;
+var computeWaterfall = function (values, labels, totalIndices) {
+    var _a, _b, _c;
+    if (totalIndices === void 0) { totalIndices = new Set(); }
+    var steps = [];
+    var cumulative = 0;
+    for (var i = 0; i < values.length; i++) {
+        var v = typeof values[i] === "number" ? values[i] : 0;
+        var isTotal = totalIndices.has(i);
+        if (isTotal) {
+            cumulative = v;
+            steps.push({
+                label: (_a = labels[i]) !== null && _a !== void 0 ? _a : String(i),
+                placeholder: 0,
+                value: v,
+                isTotal: true,
+                cumulative: cumulative,
+            });
+            continue;
+        }
+        if (v >= 0) {
+            steps.push({
+                label: (_b = labels[i]) !== null && _b !== void 0 ? _b : String(i),
+                placeholder: cumulative,
+                value: v,
+                isTotal: false,
+                cumulative: cumulative + v,
+            });
+            cumulative += v;
+        }
+        else {
+            cumulative += v;
+            steps.push({
+                label: (_c = labels[i]) !== null && _c !== void 0 ? _c : String(i),
+                placeholder: cumulative,
+                value: -v,
+                isTotal: false,
+                cumulative: cumulative,
+            });
+        }
+    }
+    return steps;
+};
+exports.computeWaterfall = computeWaterfall;

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

@@ -0,0 +1,12 @@
+/**
+ * WebGL availability probe for the 3-D chart pipeline.
+ *
+ * SSR-safe: nothing touches `document`/`window` at module scope, and the
+ * probe returns false when no DOM exists. The (browser) result is cached —
+ * context creation is not free and availability doesn't change within a
+ * page's lifetime.
+ */
+export declare const isWebGLAvailable: () => boolean;
+/** Test hook — clears the cached probe result. */
+export declare const __resetWebGLAvailabilityForTests: () => void;
+//# sourceMappingURL=webgl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webgl.d.ts","sourceRoot":"","sources":["../../../utils/webgl.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,eAAO,MAAM,gBAAgB,QAAO,OAgBnC,CAAC;AAEF,kDAAkD;AAClD,eAAO,MAAM,gCAAgC,QAAO,IAEnD,CAAC"}

package/dist/cjs/utils/webgl.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * WebGL availability probe for the 3-D chart pipeline.
+ *
+ * SSR-safe: nothing touches `document`/`window` at module scope, and the
+ * probe returns false when no DOM exists. The (browser) result is cached —
+ * context creation is not free and availability doesn't change within a
+ * page's lifetime.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__resetWebGLAvailabilityForTests = exports.isWebGLAvailable = void 0;
+var cachedResult;
+var isWebGLAvailable = function () {
+    var _a;
+    if (cachedResult !== undefined)
+        return cachedResult;
+    if (typeof document === "undefined") {
+        // SSR / non-DOM environment. Not cached: the module instance could in
+        // principle be shared with a later DOM environment.
+        return false;
+    }
+    try {
+        var canvas = document.createElement("canvas");
+        cachedResult = Boolean((_a = canvas.getContext("webgl")) !== null && _a !== void 0 ? _a : canvas.getContext("experimental-webgl"));
+    }
+    catch (_b) {
+        cachedResult = false;
+    }
+    return cachedResult;
+};
+exports.isWebGLAvailable = isWebGLAvailable;
+/** Test hook — clears the cached probe result. */
+var __resetWebGLAvailabilityForTests = function () {
+    cachedResult = undefined;
+};
+exports.__resetWebGLAvailabilityForTests = __resetWebGLAvailabilityForTests;

package/dist/cjs/vitest.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
+//# sourceMappingURL=vitest.config.d.ts.map