@rowsncolumns/charts 27.0.30

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

@@ -0,0 +1,134 @@
+/**
+ * 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.
+ */
+const isFiniteNum = (v) => typeof v === "number" && Number.isFinite(v);
+const mean = (nums) => nums.length === 0 ? 0 : nums.reduce((s, n) => s + n, 0) / nums.length;
+/**
+ * Population-style standard deviation (divides by N), matching Excel's
+ * STDEVP, which is what chart stdDev error bars use.
+ */
+const stdDev = (nums) => {
+    if (nums.length === 0)
+        return 0;
+    const m = mean(nums);
+    const variance = nums.reduce((s, n) => s + (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.
+ */
+export const resolveCustomErrorBarValues = (spec, getValuesFromRange) => {
+    if (!spec || spec.valueType !== "custom")
+        return spec;
+    const resolve = (range) => {
+        if (!range)
+            return undefined;
+        return (getValuesFromRange(range) ?? []).map((raw) => {
+            const n = typeof raw === "string" ? Number(raw) : raw;
+            return isFiniteNum(n) ? n : null;
+        });
+    };
+    return {
+        ...spec,
+        plusValues: spec.plusValues ?? resolve(spec.plusRange),
+        minusValues: spec.minusValues ?? resolve(spec.minusRange),
+    };
+};
+/**
+ * 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 const computeErrorBars = (values, spec) => {
+    if (!spec)
+        return null;
+    const valueType = spec.valueType ?? "fixedVal";
+    const barType = spec.barType ?? "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") {
+        const plusSource = barType === "minus" ? null : spec.plusValues;
+        const minusSource = barType === "plus" ? null : spec.minusValues;
+        const plus = values.map((_, i) => {
+            const v = plusSource?.[i];
+            return isFiniteNum(v) ? Math.abs(v) : 0;
+        });
+        const minus = values.map((_, i) => {
+            const v = minusSource?.[i];
+            return isFiniteNum(v) ? Math.abs(v) : 0;
+        });
+        if (plus.every((v) => v === 0) && minus.every((v) => v === 0)) {
+            return null;
+        }
+        return { plus, minus };
+    }
+    const numeric = values.filter(isFiniteNum);
+    let magnitudeFor;
+    switch (valueType) {
+        case "fixedVal": {
+            const v = isFiniteNum(spec.value) ? Math.abs(spec.value) : 0;
+            if (v === 0)
+                return null;
+            magnitudeFor = () => v;
+            break;
+        }
+        case "percentage": {
+            const pct = isFiniteNum(spec.value) ? Math.abs(spec.value) : 0;
+            if (pct === 0)
+                return null;
+            magnitudeFor = (v) => Math.abs(v) * (pct / 100);
+            break;
+        }
+        case "stdDev": {
+            const multiplier = isFiniteNum(spec.value) ? Math.abs(spec.value) : 1;
+            const sd = stdDev(numeric);
+            if (sd === 0)
+                return null;
+            const mag = sd * multiplier;
+            magnitudeFor = () => mag;
+            break;
+        }
+        case "stdErr": {
+            const sd = stdDev(numeric);
+            if (sd === 0 || numeric.length === 0)
+                return null;
+            const se = sd / Math.sqrt(numeric.length);
+            magnitudeFor = () => se;
+            break;
+        }
+        default:
+            return null;
+    }
+    const plus = [];
+    const minus = [];
+    for (const raw of values) {
+        const v = isFiniteNum(raw) ? raw : 0;
+        const mag = magnitudeFor(v);
+        plus.push(barType === "minus" ? 0 : mag);
+        minus.push(barType === "plus" ? 0 : mag);
+    }
+    return { plus, minus };
+};

package/dist/esm/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/esm/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/esm/utils/gradient.js

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ */
+/**
+ * Normalize + sort stops to echarts' `{ offset, color }` shape. Positions
+ * are clamped to 0..1; offsets <0 or >1 are not allowed by echarts.
+ */
+const toColorStops = (stops) => {
+    return (stops ?? [])
+        .filter((s) => s && typeof s.color === "string")
+        .map((s) => ({
+        offset: Math.max(0, Math.min(1, s.position ?? 0)),
+        color: s.color,
+    }))
+        .sort((a, b) => 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.
+ */
+const degreeToEndpoints = (degree) => {
+    const rad = (degree * Math.PI) / 180;
+    // Direction vector of the gradient axis.
+    const dx = Math.cos(rad);
+    const 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).
+ */
+export const gradientToEcharts = (gradient) => {
+    if (!gradient)
+        return null;
+    const 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.
+    const stops = colorStops.length === 1
+        ? [colorStops[0], { offset: 1, color: colorStops[0].color }]
+        : colorStops;
+    const { x, y, x2, y2 } = degreeToEndpoints(gradient.degree ?? 90);
+    return { x, y, x2, y2, colorStops: stops };
+};
+/**
+ * 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 const gradientToPlotly = (gradient) => {
+    if (!gradient)
+        return undefined;
+    const 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;
+};

package/dist/esm/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/esm/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/esm/utils/hierarchy.js

@@ -0,0 +1,150 @@
+const flattenChartData = (chartData, extractor, hiddenStrategy, skipFirstRow = false) => {
+    if (!chartData || chartData.length === 0)
+        return [];
+    const values = [];
+    chartData.forEach((entry) => {
+        entry.sources.forEach((source) => {
+            const extracted = extractor(source, hiddenStrategy) ?? [];
+            const trimmed = skipFirstRow && extracted.length > 0 ? extracted.slice(1) : extracted;
+            values.push(...trimmed);
+        });
+    });
+    return values;
+};
+const toLabelString = (value) => {
+    if (value === null || value === undefined)
+        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;
+    }
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    if (typeof value === "boolean") {
+        return value ? 1 : 0;
+    }
+    return null;
+};
+export const getHierarchyHeaderTitle = (spec, options) => {
+    if (spec.useFirstRowAsHeaders === false)
+        return undefined;
+    const { getDomainValuesFromRange } = options;
+    for (const entry of spec.parentLabels ?? []) {
+        for (const source of entry.sources ?? []) {
+            const values = getDomainValuesFromRange(source, options.hiddenDimensionStrategy) ?? [];
+            if (values.length > 0) {
+                const header = toLabelString(values[0]);
+                if (header) {
+                    return header;
+                }
+            }
+        }
+    }
+    return undefined;
+};
+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);
+    const sizes = flattenChartData(spec.sizeData, getSeriesValuesFromRange, hiddenStrategy, skipHeaders);
+    const rows = [];
+    const seenLabels = new Set();
+    for (let i = 0; i < labels.length; i++) {
+        const label = labels[i];
+        if (!label)
+            continue;
+        if (seenLabels.has(label)) {
+            throw new Error(`Duplicate hierarchy label detected: ${label}`);
+        }
+        seenLabels.add(label);
+        rows.push({
+            label,
+            parent: toParentLabel(parents[i]),
+            value: toNumericValue(sizes[i]),
+        });
+    }
+    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(),
+    };
+    nodes.set(name, node);
+    return node;
+};
+export const buildHierarchyTree = (rows) => {
+    const nodes = new Map();
+    rows.forEach((row) => {
+        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 buildNode = (internal) => {
+        const children = internal.children.size > 0
+            ? Array.from(internal.children).map((childName) => buildNode(getOrCreateNode(nodes, childName)))
+            : 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,
+            value,
+        };
+        if (children && children.length > 0) {
+            node.children = children;
+        }
+        return node;
+    };
+    const roots = [];
+    nodes.forEach((internal) => {
+        if (internal.parent == null) {
+            roots.push(buildNode(internal));
+        }
+    });
+    return roots;
+};
+export const toPlotlyHierarchy = (rows) => {
+    const tree = buildHierarchyTree(rows);
+    const labels = [];
+    const parents = [];
+    const values = [];
+    const traverse = (nodes, parentName) => {
+        nodes.forEach((node) => {
+            labels.push(node.name);
+            parents.push(parentName ?? "");
+            values.push(node.value ?? 0);
+            if (node.children) {
+                traverse(node.children, node.name);
+            }
+        });
+    };
+    traverse(tree, null);
+    return { labels, parents, values };
+};

package/dist/esm/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/esm/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/esm/utils/histogram.js

@@ -0,0 +1,95 @@
+/**
+ * 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.
+ */
+/**
+ * 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 const isParetoSpec = (spec) => spec.chartType === "pareto" ||
+    (typeof spec.sourceChartType === "string" &&
+        spec.sourceChartType.toUpperCase() === "PARETO");
+/**
+ * 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 const computePareto = (bins) => {
+    const order = bins.counts.map((_, i) => i);
+    order.sort((a, b) => bins.counts[b] - bins.counts[a] || a - b);
+    const counts = order.map((i) => bins.counts[i]);
+    const labels = order.map((i) => bins.labels[i] ?? "");
+    const total = counts.reduce((sum, c) => sum + c, 0);
+    const cumulativePercents = new Array(counts.length);
+    let running = 0;
+    for (let 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, counts, cumulativePercents };
+};
+const formatBinBound = (value) => {
+    if (!Number.isFinite(value))
+        return String(value);
+    const 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).
+ */
+export const binHistogram = (values, binCount) => {
+    const numeric = values.filter((v) => typeof v === "number" && Number.isFinite(v));
+    if (numeric.length === 0) {
+        return { labels: [], counts: [] };
+    }
+    let min = numeric[0];
+    let max = numeric[0];
+    for (const v of numeric) {
+        if (v < min)
+            min = v;
+        if (v > max)
+            max = v;
+    }
+    const sturges = Math.max(1, Math.ceil(Math.log2(numeric.length) + 1));
+    const bins = typeof binCount === "number" && binCount > 0
+        ? Math.floor(binCount)
+        : sturges;
+    if (min === max) {
+        return { labels: [formatBinBound(min)], counts: [numeric.length] };
+    }
+    const width = (max - min) / bins;
+    const counts = new Array(bins).fill(0);
+    for (const v of numeric) {
+        let idx = Math.floor((v - min) / width);
+        if (idx >= bins)
+            idx = bins - 1;
+        if (idx < 0)
+            idx = 0;
+        counts[idx]++;
+    }
+    const labels = new Array(bins);
+    for (let i = 0; i < bins; i++) {
+        const lo = min + width * i;
+        const hi = min + width * (i + 1);
+        const closing = i === bins - 1 ? "]" : ")";
+        labels[i] = `[${formatBinBound(lo)}, ${formatBinBound(hi)}${closing}`;
+    }
+    return { labels, counts };
+};