@rowsncolumns/charts 27.0.30

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

@@ -0,0 +1,46 @@
+/**
+ * Histogram binning utility shared by chart renderers.
+ *
+ * Plotly has native histogram trace support, so it does its own binning.
+ * Echarts has no native histogram series, so the renderer pre-bins values
+ * here and emits a bar series with the bin labels as the x-axis category.
+ */
+export type HistogramBins = {
+    labels: string[];
+    counts: number[];
+};
+export type ParetoData = {
+    /** Bin labels reordered by descending count. */
+    labels: string[];
+    /** Bin counts sorted descending (stable — ties keep bin order). */
+    counts: number[];
+    /**
+     * Running cumulative percentage of the total count per sorted bin.
+     * The final entry is exactly 100 (avoids float drift), so the line
+     * always meets the top of a 0-100 secondary axis.
+     */
+    cumulativePercents: number[];
+};
+/**
+ * True when a chart spec should render as a Pareto chart: either a
+ * native `pareto` chartType token, or a histogram payload that was
+ * degraded from an authored Pareto chart (`sourceChartType: "PARETO"`,
+ * preserved verbatim through the document).
+ */
+export declare const isParetoSpec: (spec: {
+    chartType?: string;
+    sourceChartType?: string | null;
+}) => boolean;
+/**
+ * Transform histogram bins into Pareto form: bins sorted by count
+ * descending (stable sort — equal counts keep their original bin
+ * order) plus the cumulative percentage of the running total for the
+ * secondary-axis overlay line.
+ */
+export declare const computePareto: (bins: HistogramBins) => ParetoData;
+/**
+ * Bin a set of numeric values into `binCount` equal-width bins.
+ * When `binCount` is omitted, uses Sturges' rule: ceil(log2(n) + 1).
+ */
+export declare const binHistogram: (values: (number | null | undefined)[], binCount?: number | null) => HistogramBins;
+//# sourceMappingURL=histogram.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"histogram.d.ts","sourceRoot":"","sources":["../../../utils/histogram.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,gDAAgD;IAChD,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,mEAAmE;IACnE,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB;;;;OAIG;IACH,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC,KAAG,OAGgD,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,aAAa,KAAG,UAmBnD,CAAC;AASF;;;GAGG;AACH,eAAO,MAAM,YAAY,GACvB,QAAQ,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACrC,WAAW,MAAM,GAAG,IAAI,KACvB,aA0CF,CAAC"}

package/dist/cjs/utils/histogram.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * Histogram binning utility shared by chart renderers.
+ *
+ * Plotly has native histogram trace support, so it does its own binning.
+ * Echarts has no native histogram series, so the renderer pre-bins values
+ * here and emits a bar series with the bin labels as the x-axis category.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binHistogram = exports.computePareto = exports.isParetoSpec = void 0;
+var tslib_1 = require("tslib");
+/**
+ * True when a chart spec should render as a Pareto chart: either a
+ * native `pareto` chartType token, or a histogram payload that was
+ * degraded from an authored Pareto chart (`sourceChartType: "PARETO"`,
+ * preserved verbatim through the document).
+ */
+var isParetoSpec = function (spec) {
+    return spec.chartType === "pareto" ||
+        (typeof spec.sourceChartType === "string" &&
+            spec.sourceChartType.toUpperCase() === "PARETO");
+};
+exports.isParetoSpec = isParetoSpec;
+/**
+ * Transform histogram bins into Pareto form: bins sorted by count
+ * descending (stable sort — equal counts keep their original bin
+ * order) plus the cumulative percentage of the running total for the
+ * secondary-axis overlay line.
+ */
+var computePareto = function (bins) {
+    var order = bins.counts.map(function (_, i) { return i; });
+    order.sort(function (a, b) { return bins.counts[b] - bins.counts[a] || a - b; });
+    var counts = order.map(function (i) { return bins.counts[i]; });
+    var labels = order.map(function (i) { var _a; return (_a = bins.labels[i]) !== null && _a !== void 0 ? _a : ""; });
+    var total = counts.reduce(function (sum, c) { return sum + c; }, 0);
+    var cumulativePercents = new Array(counts.length);
+    var running = 0;
+    for (var i = 0; i < counts.length; i++) {
+        running += counts[i];
+        if (total <= 0) {
+            cumulativePercents[i] = 0;
+        }
+        else if (i === counts.length - 1) {
+            cumulativePercents[i] = 100;
+        }
+        else {
+            cumulativePercents[i] = (running / total) * 100;
+        }
+    }
+    return { labels: labels, counts: counts, cumulativePercents: cumulativePercents };
+};
+exports.computePareto = computePareto;
+var formatBinBound = function (value) {
+    if (!Number.isFinite(value))
+        return String(value);
+    var abs = Math.abs(value);
+    if (abs >= 1000 || abs < 0.01)
+        return value.toExponential(2);
+    return Number.parseFloat(value.toFixed(2)).toString();
+};
+/**
+ * Bin a set of numeric values into `binCount` equal-width bins.
+ * When `binCount` is omitted, uses Sturges' rule: ceil(log2(n) + 1).
+ */
+var binHistogram = function (values, binCount) {
+    var e_1, _a, e_2, _b;
+    var numeric = values.filter(function (v) { return typeof v === "number" && Number.isFinite(v); });
+    if (numeric.length === 0) {
+        return { labels: [], counts: [] };
+    }
+    var min = numeric[0];
+    var max = numeric[0];
+    try {
+        for (var numeric_1 = tslib_1.__values(numeric), numeric_1_1 = numeric_1.next(); !numeric_1_1.done; numeric_1_1 = numeric_1.next()) {
+            var v = numeric_1_1.value;
+            if (v < min)
+                min = v;
+            if (v > max)
+                max = v;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (numeric_1_1 && !numeric_1_1.done && (_a = numeric_1.return)) _a.call(numeric_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var sturges = Math.max(1, Math.ceil(Math.log2(numeric.length) + 1));
+    var bins = typeof binCount === "number" && binCount > 0
+        ? Math.floor(binCount)
+        : sturges;
+    if (min === max) {
+        return { labels: [formatBinBound(min)], counts: [numeric.length] };
+    }
+    var width = (max - min) / bins;
+    var counts = new Array(bins).fill(0);
+    try {
+        for (var numeric_2 = tslib_1.__values(numeric), numeric_2_1 = numeric_2.next(); !numeric_2_1.done; numeric_2_1 = numeric_2.next()) {
+            var v = numeric_2_1.value;
+            var idx = Math.floor((v - min) / width);
+            if (idx >= bins)
+                idx = bins - 1;
+            if (idx < 0)
+                idx = 0;
+            counts[idx]++;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (numeric_2_1 && !numeric_2_1.done && (_b = numeric_2.return)) _b.call(numeric_2);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    var labels = new Array(bins);
+    for (var i = 0; i < bins; i++) {
+        var lo = min + width * i;
+        var hi = min + width * (i + 1);
+        var closing = i === bins - 1 ? "]" : ")";
+        labels[i] = "[".concat(formatBinBound(lo), ", ").concat(formatBinBound(hi)).concat(closing);
+    }
+    return { labels: labels, counts: counts };
+};
+exports.binHistogram = binHistogram;

package/dist/cjs/utils/of-pie.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Pie-of-pie / bar-of-pie (OOXML `<c:ofPieChart>`) split math.
+ *
+ * Excel splits the minor slices of a pie into a secondary pie or
+ * stacked bar next to the main pie. The main pie replaces the moved
+ * slices with a single aggregated "Other" slice, and connector lines
+ * join the Other slice to the secondary plot. The rule deciding which
+ * points move is `<c:splitType>` + `<c:splitPos>`:
+ *
+ *   - position — the last `splitPos` categories move (Excel default,
+ *     `splitPos` 3)
+ *   - value    — points whose value is < `splitPos` move
+ *   - percent  — points whose share of the grand total is < `splitPos`%
+ *     move
+ *
+ * OOXML also allows `auto` (app decides) and `cust` (explicit per-point
+ * assignment via `<c:custSplit>`). Neither has a spec representation
+ * here, so both degrade to Excel's default: position with `splitPos` 3.
+ */
+type MaybeLike<T> = T | null | undefined;
+export type OfPieType = "pie" | "bar";
+export type OfPieSplitType = "position" | "value" | "percent";
+/** Excel's default split: the last 3 categories move to the second plot. */
+export declare const DEFAULT_OF_PIE_SPLIT_POS = 3;
+/** OOXML `<c:secondPieSize>` default — secondary plot is 75% of the main pie. */
+export declare const DEFAULT_SECOND_PIE_SIZE = 75;
+/** Label of the aggregated slice representing the secondary plot's total. */
+export declare const OF_PIE_OTHER_LABEL = "Other";
+export type OfPieSlice = {
+    label: string;
+    value: number;
+};
+export type OfPieSplitResult = {
+    /**
+     * Main-pie slices. When the secondary plot is non-empty the last
+     * entry is the aggregated "Other" slice (value = `otherTotal`).
+     */
+    main: OfPieSlice[];
+    /** Secondary-plot slices, in original data order. */
+    secondary: OfPieSlice[];
+    /** Sum of the secondary values — the "Other" slice's value. */
+    otherTotal: number;
+    /** Grand total of all (finite) input values. */
+    total: number;
+};
+export type OfPieSplitOptions = {
+    /**
+     * Accepts both spec tokens ("position" | "value" | "percent") and
+     * raw OOXML tokens ("pos" | "val" | "percent" | "auto" | "cust").
+     * Unknown/absent values fall back to "position".
+     */
+    splitType?: MaybeLike<string>;
+    /** Threshold for the split rule. Defaults to 3 (Excel's default). */
+    splitPos?: MaybeLike<number>;
+    /** Override for the aggregated slice's label. Defaults to "Other". */
+    otherLabel?: MaybeLike<string>;
+};
+/**
+ * Normalize a split-type token to the renderer's vocabulary. Maps the
+ * raw OOXML tokens (`pos`/`val`) and degrades `auto`/`cust`/unknown to
+ * "position" (Excel's default behavior).
+ */
+export declare const normalizeOfPieSplitType: (raw: MaybeLike<string>) => OfPieSplitType;
+/** Coerce `<c:ofPieType>`-ish input to "pie" | "bar" (default "pie"). */
+export declare const resolveOfPieType: (raw: MaybeLike<string>) => OfPieType;
+/** Clamp `<c:secondPieSize>` to its OOXML 5–200 range (default 75). */
+export declare const clampSecondPieSize: (raw: MaybeLike<number>) => number;
+/**
+ * True when a basic-chart spec should render as an of-pie composite:
+ * a pie chart whose authored type was OF_PIE, or one that explicitly
+ * carries an `ofPieType`. Plain pies (neither marker) are unaffected.
+ */
+export declare const isOfPieChartSpec: (spec: {
+    chartType?: string;
+    sourceChartType?: MaybeLike<string>;
+    ofPieType?: MaybeLike<string>;
+}) => boolean;
+/**
+ * Half of the angle (radians) subtended by the "Other" slice. The
+ * renderers rotate the main pie so the Other slice's angular midpoint
+ * points at the secondary plot; the two connector lines then leave the
+ * circle at ±this angle from that midpoint.
+ */
+export declare const otherSliceHalfAngle: (otherTotal: number, total: number) => number;
+/**
+ * Split a pie's data points into the main plot (+ aggregated "Other"
+ * slice) and the secondary plot, honoring the of-pie split rule.
+ *
+ * Degenerate inputs degrade gracefully:
+ *   - empty values → both plots empty
+ *   - a single point never moves (the main pie keeps ≥ 1 real slice
+ *     under the position rule; value/percent rules may move everything,
+ *     leaving the main pie as a single 100% "Other" slice — Excel does
+ *     the same)
+ *   - position `splitPos` larger than the point count is clamped to
+ *     `count - 1`
+ *   - an empty secondary plot yields no "Other" slice (plain pie)
+ */
+export declare const splitOfPie: (values: MaybeLike<number>[], labels: MaybeLike<string | number>[], options?: OfPieSplitOptions) => OfPieSplitResult;
+export {};
+//# sourceMappingURL=of-pie.d.ts.map

package/dist/cjs/utils/of-pie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"of-pie.d.ts","sourceRoot":"","sources":["../../../utils/of-pie.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;AAEzC,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,CAAC;AACtC,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,OAAO,GAAG,SAAS,CAAC;AAE9D,4EAA4E;AAC5E,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAC1C,iFAAiF;AACjF,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,6EAA6E;AAC7E,eAAO,MAAM,kBAAkB,UAAU,CAAC;AAE1C,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;OAGG;IACH,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,qDAAqD;IACrD,SAAS,EAAE,UAAU,EAAE,CAAC;IACxB,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAC9B,qEAAqE;IACrE,QAAQ,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAC7B,sEAAsE;IACtE,UAAU,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CAChC,CAAC;AAOF;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,GAClC,KAAK,SAAS,CAAC,MAAM,CAAC,KACrB,cAeF,CAAC;AAEF,yEAAyE;AACzE,eAAO,MAAM,gBAAgB,GAAI,KAAK,SAAS,CAAC,MAAM,CAAC,KAAG,SACC,CAAC;AAE5D,uEAAuE;AACvE,eAAO,MAAM,kBAAkB,GAAI,KAAK,SAAS,CAAC,MAAM,CAAC,KAAG,MAM3D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IACpC,SAAS,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CAC/B,KAAG,OAIyB,CAAC;AAE9B;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAC9B,YAAY,MAAM,EAClB,OAAO,MAAM,KACZ,MAIF,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,GACrB,QAAQ,SAAS,CAAC,MAAM,CAAC,EAAE,EAC3B,QAAQ,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EACpC,UAAU,iBAAiB,KAC1B,gBAiDF,CAAC"}

package/dist/cjs/utils/of-pie.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * Pie-of-pie / bar-of-pie (OOXML `<c:ofPieChart>`) split math.
+ *
+ * Excel splits the minor slices of a pie into a secondary pie or
+ * stacked bar next to the main pie. The main pie replaces the moved
+ * slices with a single aggregated "Other" slice, and connector lines
+ * join the Other slice to the secondary plot. The rule deciding which
+ * points move is `<c:splitType>` + `<c:splitPos>`:
+ *
+ *   - position — the last `splitPos` categories move (Excel default,
+ *     `splitPos` 3)
+ *   - value    — points whose value is < `splitPos` move
+ *   - percent  — points whose share of the grand total is < `splitPos`%
+ *     move
+ *
+ * OOXML also allows `auto` (app decides) and `cust` (explicit per-point
+ * assignment via `<c:custSplit>`). Neither has a spec representation
+ * here, so both degrade to Excel's default: position with `splitPos` 3.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitOfPie = exports.otherSliceHalfAngle = exports.isOfPieChartSpec = exports.clampSecondPieSize = exports.resolveOfPieType = exports.normalizeOfPieSplitType = exports.OF_PIE_OTHER_LABEL = exports.DEFAULT_SECOND_PIE_SIZE = exports.DEFAULT_OF_PIE_SPLIT_POS = void 0;
+/** Excel's default split: the last 3 categories move to the second plot. */
+exports.DEFAULT_OF_PIE_SPLIT_POS = 3;
+/** OOXML `<c:secondPieSize>` default — secondary plot is 75% of the main pie. */
+exports.DEFAULT_SECOND_PIE_SIZE = 75;
+/** Label of the aggregated slice representing the secondary plot's total. */
+exports.OF_PIE_OTHER_LABEL = "Other";
+var toFiniteNumber = function (value) {
+    var n = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(n) ? n : 0;
+};
+/**
+ * Normalize a split-type token to the renderer's vocabulary. Maps the
+ * raw OOXML tokens (`pos`/`val`) and degrades `auto`/`cust`/unknown to
+ * "position" (Excel's default behavior).
+ */
+var normalizeOfPieSplitType = function (raw) {
+    switch (String(raw !== null && raw !== void 0 ? raw : "").toLowerCase()) {
+        case "value":
+        case "val":
+            return "value";
+        case "percent":
+            return "percent";
+        case "position":
+        case "pos":
+            return "position";
+        // "auto" / "cust" / unknown — no renderer equivalent, use Excel's
+        // default rule.
+        default:
+            return "position";
+    }
+};
+exports.normalizeOfPieSplitType = normalizeOfPieSplitType;
+/** Coerce `<c:ofPieType>`-ish input to "pie" | "bar" (default "pie"). */
+var resolveOfPieType = function (raw) {
+    return String(raw !== null && raw !== void 0 ? raw : "").toLowerCase() === "bar" ? "bar" : "pie";
+};
+exports.resolveOfPieType = resolveOfPieType;
+/** Clamp `<c:secondPieSize>` to its OOXML 5–200 range (default 75). */
+var clampSecondPieSize = function (raw) {
+    var v = typeof raw === "number" && Number.isFinite(raw)
+        ? raw
+        : exports.DEFAULT_SECOND_PIE_SIZE;
+    return Math.min(200, Math.max(5, v));
+};
+exports.clampSecondPieSize = clampSecondPieSize;
+/**
+ * True when a basic-chart spec should render as an of-pie composite:
+ * a pie chart whose authored type was OF_PIE, or one that explicitly
+ * carries an `ofPieType`. Plain pies (neither marker) are unaffected.
+ */
+var isOfPieChartSpec = function (spec) {
+    var _a;
+    return (spec === null || spec === void 0 ? void 0 : spec.chartType) === "pie" &&
+        (String((_a = spec.sourceChartType) !== null && _a !== void 0 ? _a : "").toUpperCase() === "OF_PIE" ||
+            spec.ofPieType === "pie" ||
+            spec.ofPieType === "bar");
+};
+exports.isOfPieChartSpec = isOfPieChartSpec;
+/**
+ * Half of the angle (radians) subtended by the "Other" slice. The
+ * renderers rotate the main pie so the Other slice's angular midpoint
+ * points at the secondary plot; the two connector lines then leave the
+ * circle at ±this angle from that midpoint.
+ */
+var otherSliceHalfAngle = function (otherTotal, total) {
+    if (!(total > 0))
+        return 0;
+    var fraction = Math.min(1, Math.max(0, otherTotal / total));
+    return Math.PI * fraction;
+};
+exports.otherSliceHalfAngle = otherSliceHalfAngle;
+/**
+ * Split a pie's data points into the main plot (+ aggregated "Other"
+ * slice) and the secondary plot, honoring the of-pie split rule.
+ *
+ * Degenerate inputs degrade gracefully:
+ *   - empty values → both plots empty
+ *   - a single point never moves (the main pie keeps ≥ 1 real slice
+ *     under the position rule; value/percent rules may move everything,
+ *     leaving the main pie as a single 100% "Other" slice — Excel does
+ *     the same)
+ *   - position `splitPos` larger than the point count is clamped to
+ *     `count - 1`
+ *   - an empty secondary plot yields no "Other" slice (plain pie)
+ */
+var splitOfPie = function (values, labels, options) {
+    var _a;
+    var slices = (values !== null && values !== void 0 ? values : []).map(function (v, i) {
+        var _a;
+        return ({
+            label: String((_a = labels === null || labels === void 0 ? void 0 : labels[i]) !== null && _a !== void 0 ? _a : ""),
+            value: toFiniteNumber(v),
+        });
+    });
+    var total = slices.reduce(function (sum, s) { return sum + s.value; }, 0);
+    var splitType = (0, exports.normalizeOfPieSplitType)(options === null || options === void 0 ? void 0 : options.splitType);
+    var splitPos = typeof (options === null || options === void 0 ? void 0 : options.splitPos) === "number" && Number.isFinite(options.splitPos)
+        ? options.splitPos
+        : exports.DEFAULT_OF_PIE_SPLIT_POS;
+    var moved = slices.map(function () { return false; });
+    if (slices.length > 1) {
+        if (splitType === "position") {
+            // Last N categories; the main pie keeps at least one real slice.
+            var n = Math.min(Math.max(Math.floor(splitPos), 0), slices.length - 1);
+            for (var i = slices.length - n; i < slices.length; i++) {
+                moved[i] = true;
+            }
+        }
+        else if (splitType === "value") {
+            slices.forEach(function (s, i) {
+                if (s.value < splitPos)
+                    moved[i] = true;
+            });
+        }
+        else {
+            // percent — share of the grand total below splitPos%.
+            slices.forEach(function (s, i) {
+                if (total > 0 && (s.value / total) * 100 < splitPos)
+                    moved[i] = true;
+            });
+        }
+    }
+    var main = [];
+    var secondary = [];
+    slices.forEach(function (s, i) {
+        (moved[i] ? secondary : main).push(s);
+    });
+    var otherTotal = secondary.reduce(function (sum, s) { return sum + s.value; }, 0);
+    if (secondary.length > 0) {
+        main.push({
+            label: (_a = options === null || options === void 0 ? void 0 : options.otherLabel) !== null && _a !== void 0 ? _a : exports.OF_PIE_OTHER_LABEL,
+            value: otherTotal,
+        });
+    }
+    return { main: main, secondary: secondary, otherTotal: otherTotal, total: total };
+};
+exports.splitOfPie = splitOfPie;

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

@@ -0,0 +1,12 @@
+import type { LegendComponentOption } from "echarts";
+/** Build an echarts `textStyle` from a parsed `ChartTextFormat`. */
+export declare const textFormatToEchartsTextStyle: (fmt: any) => Record<string, any> | undefined;
+export declare const applyLegendOverrides: (legend: LegendComponentOption, opts: any) => LegendComponentOption;
+export declare const applyAxisOverrides: (axis: any, opts: any) => any;
+export declare const dataLabelFormatter: (opts: any) => (params: any) => string;
+export declare const buildSeriesLabelOption: (opts: any) => {
+    readonly show: true;
+    readonly position: any;
+    readonly formatter: (params: any) => string;
+} | undefined;
+//# sourceMappingURL=overrides.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"overrides.d.ts","sourceRoot":"","sources":["../../../utils/overrides.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AASrD,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,eAAO,MAAM,kBAAkB,GAAI,MAAM,GAAG,EAAE,MAAM,GAAG,QAsBtD,CAAC;AAqBF,eAAO,MAAM,kBAAkB,GAAI,MAAM,GAAG,MAAM,QAAQ,GAAG,WA4B5D,CAAC;AAWF,eAAO,MAAM,sBAAsB,GAAI,MAAM,GAAG;;;iCAvCU,GAAG;aA+C5D,CAAC"}

package/dist/cjs/utils/overrides.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSeriesLabelOption = exports.dataLabelFormatter = exports.applyAxisOverrides = exports.applyLegendOverrides = exports.textFormatToEchartsTextStyle = void 0;
+var tslib_1 = require("tslib");
+var utils_1 = require("@rowsncolumns/utils");
+// Map ChartSpec.legend / dataLabels / axisOptions to ECharts option
+// fragments. Each helper is a no-op when the spec field is missing, so
+// callers can spread the result without checks. Shared by the main
+// option assembly and the bubble / hierarchy / radar / stock early
+// branches in `basic-chart.tsx` so every chart type honors the same
+// spec-level overrides.
+/** Build an echarts `textStyle` from a parsed `ChartTextFormat`. */
+var textFormatToEchartsTextStyle = function (fmt) {
+    if (!fmt)
+        return undefined;
+    var result = {};
+    if (fmt.color)
+        result.color = fmt.color;
+    if (fmt.fontFamily)
+        result.fontFamily = fmt.fontFamily;
+    if (typeof fmt.fontSize === "number")
+        result.fontSize = fmt.fontSize;
+    if (fmt.bold)
+        result.fontWeight = "bold";
+    if (fmt.italic)
+        result.fontStyle = "italic";
+    return Object.keys(result).length ? result : undefined;
+};
+exports.textFormatToEchartsTextStyle = textFormatToEchartsTextStyle;
+var applyLegendOverrides = function (legend, opts) {
+    var _a;
+    if (!opts)
+        return legend;
+    var next = tslib_1.__assign({}, legend);
+    if (opts.position === "none") {
+        next.show = false;
+        return next;
+    }
+    next.show = true;
+    switch (opts.position) {
+        case "top":
+            next.top = 10;
+            next.bottom = undefined;
+            next.left = "center";
+            next.orient = "horizontal";
+            break;
+        case "bottom":
+            next.bottom = 10;
+            next.top = undefined;
+            next.left = "center";
+            next.orient = "horizontal";
+            break;
+        case "left":
+            next.left = 0;
+            next.right = undefined;
+            next.top = "middle";
+            next.orient = "vertical";
+            break;
+        case "right":
+            next.right = 0;
+            next.left = undefined;
+            next.top = "middle";
+            next.orient = "vertical";
+            break;
+        case "topRight":
+            next.top = 10;
+            next.right = 0;
+            next.left = undefined;
+            next.orient = "vertical";
+            break;
+    }
+    var legendTextStyle = (0, exports.textFormatToEchartsTextStyle)(opts.textFormat);
+    if (legendTextStyle) {
+        next.textStyle = tslib_1.__assign(tslib_1.__assign({}, ((_a = next.textStyle) !== null && _a !== void 0 ? _a : {})), legendTextStyle);
+    }
+    return next;
+};
+exports.applyLegendOverrides = applyLegendOverrides;
+var applyAxisOverrides = function (axis, opts) {
+    var _a, _b, _c, _d;
+    if (!opts)
+        return axis;
+    var next = tslib_1.__assign({}, axis);
+    if (opts.logarithmic)
+        next.type = "log";
+    if (opts.reverse)
+        next.inverse = true;
+    if (typeof opts.min === "number")
+        next.min = opts.min;
+    if (typeof opts.max === "number")
+        next.max = opts.max;
+    if (opts.visible === false)
+        next.show = false;
+    if (opts.showMajorGridlines === false) {
+        next.splitLine = tslib_1.__assign(tslib_1.__assign({}, ((_a = next.splitLine) !== null && _a !== void 0 ? _a : {})), { show: false });
+    }
+    if (opts.showMajorGridlines === true) {
+        next.splitLine = tslib_1.__assign(tslib_1.__assign({}, ((_b = next.splitLine) !== null && _b !== void 0 ? _b : {})), { show: true });
+    }
+    // Axis label text style (tick labels) + axis title font come from
+    // <c:txPr>. Without this echarts uses its default (~black on light).
+    var axisTextStyle = (0, exports.textFormatToEchartsTextStyle)(opts.textFormat);
+    if (axisTextStyle) {
+        next.axisLabel = tslib_1.__assign(tslib_1.__assign({}, ((_c = next.axisLabel) !== null && _c !== void 0 ? _c : {})), axisTextStyle);
+        next.nameTextStyle = tslib_1.__assign(tslib_1.__assign({}, ((_d = next.nameTextStyle) !== null && _d !== void 0 ? _d : {})), axisTextStyle);
+    }
+    return next;
+};
+exports.applyAxisOverrides = applyAxisOverrides;
+/**
+ * Format a numeric data-label value through the chart's
+ * `<c:dLbls><c:numFmt formatCode=…>` pattern when present. For
+ * percent-stacked bars the `originalValue` (raw dollars) is preferred
+ * over the normalized percentage so labels read "$1,831" not "84.6"
+ * — Excel's behaviour.
+ */
+var formatLabelValue = function (rawValue, originalValue, pattern) {
+    var target = originalValue !== null && originalValue !== void 0 ? originalValue : rawValue;
+    if (pattern) {
+        return (0, utils_1.ssfFormat)(pattern, target);
+    }
+    return target === undefined || target === null ? "" : String(target);
+};
+var dataLabelFormatter = function (opts) { return function (params) {
+    var parts = [];
+    if (opts.showSeriesName && params.seriesName)
+        parts.push(params.seriesName);
+    if (opts.showCategoryName && params.name)
+        parts.push(params.name);
+    if (opts.showPercent && params.percent !== undefined) {
+        parts.push("".concat(params.percent, "%"));
+    }
+    var showVal = opts.showValue !== false &&
+        !opts.showCategoryName &&
+        !opts.showPercent &&
+        !opts.showSeriesName
+        ? true
+        : !!opts.showValue;
+    if (showVal && params.value !== 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
+        // scalar `value`.
+        var originalValue = typeof params.data === "object" && params.data
+            ? params.data.originalValue
+            : undefined;
+        parts.push(formatLabelValue(params.value, originalValue, opts.numberFormatPattern));
+    }
+    return parts.join(": ");
+}; };
+exports.dataLabelFormatter = dataLabelFormatter;
+var ECHARTS_DLBL_POS = {
+    center: "inside",
+    inside: "inside",
+    outside: "outside",
+    insideEnd: "insideTop",
+    outsideEnd: "top",
+    bestFit: "top",
+};
+var buildSeriesLabelOption = function (opts) {
+    var _a;
+    if (!(opts === null || opts === void 0 ? void 0 : opts.show))
+        return undefined;
+    var position = (_a = (opts.position && ECHARTS_DLBL_POS[opts.position])) !== null && _a !== void 0 ? _a : "top";
+    return {
+        show: true,
+        position: position,
+        formatter: (0, exports.dataLabelFormatter)(opts),
+    };
+};
+exports.buildSeriesLabelOption = buildSeriesLabelOption;

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

@@ -0,0 +1,37 @@
+/**
+ * Radar-chart shaping shared by chart renderers.
+ *
+ * A radar chart plots each series as a closed polygon over a set of
+ * "indicators" (one axis per category). echarts needs a top-level
+ * `radar.indicator: [{ name, max }]` plus series of shape
+ * `{ value: number[], name }`. plotly uses `scatterpolar` traces with
+ * `r` (the values) and `theta` (the category names).
+ *
+ * These helpers are pure transforms over already-extracted category
+ * labels and per-series numeric values.
+ */
+export type RadarSeriesInput = {
+    name: string;
+    values: (number | null | undefined)[];
+};
+export type RadarIndicator = {
+    name: string;
+    max: number;
+};
+/**
+ * Build echarts radar indicators from category labels and series.
+ * The `max` per indicator is the largest value seen across all series at
+ * that category (rounded up a touch so the polygon doesn't touch the
+ * rim). When every series is empty at an index, `max` defaults to 1.
+ */
+export declare const buildRadarIndicators: (categories: (string | number | boolean | null | undefined)[], series: RadarSeriesInput[]) => RadarIndicator[];
+/**
+ * Shape series into echarts radar data: one entry per series with its
+ * value vector aligned to the indicator order. Missing/non-numeric
+ * values become 0 so the polygon stays closed.
+ */
+export declare const buildRadarSeriesData: (series: RadarSeriesInput[], indicatorCount: number) => Array<{
+    value: number[];
+    name: string;
+}>;
+//# sourceMappingURL=radar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"radar.d.ts","sourceRoot":"","sources":["../../../utils/radar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAQ3D;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,YAAY,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EAC5D,QAAQ,gBAAgB,EAAE,KACzB,cAAc,EAahB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,gBAAgB,EAAE,EAC1B,gBAAgB,MAAM,KACrB,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAQzC,CAAC"}