@rowsncolumns/charts 27.0.30

package/dist/esm/plotly/basic-chart/helpers.d.ts

@@ -0,0 +1,20 @@
+import type { EmbeddedChart } from "@rowsncolumns/spreadsheet";
+export declare const chartTypeToPlotlyType: (type: EmbeddedChart["spec"]["chartType"]) => string;
+export declare const getPlotlyTraceStyle: (type: EmbeddedChart["spec"]["chartType"]) => {
+    mode: "lines";
+    fill?: undefined;
+} | {
+    mode: "lines";
+    fill: "tozeroy";
+} | {
+    mode?: undefined;
+    fill?: undefined;
+};
+/**
+ * Map OOXML `<c:marker><c:symbol val=…>` to plotly marker symbol names.
+ * OOXML symbols don't all have direct plotly equivalents — closest
+ * visual analog is used.
+ */
+export declare const mapMarkerSymbolToPlotly: (symbol: string | undefined | null) => string | undefined;
+export declare const showXAxis: (type: EmbeddedChart["spec"]["chartType"]) => boolean;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/esm/plotly/basic-chart/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../plotly/basic-chart/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D,eAAO,MAAM,qBAAqB,GAChC,MAAM,aAAa,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,KACvC,MA+DF,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,MAAM,aAAa,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC;;;;;;;;;CAgBzC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,GAClC,QAAQ,MAAM,GAAG,SAAS,GAAG,IAAI,KAChC,MAAM,GAAG,SA0BX,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,MAAM,aAAa,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,YAejE,CAAC"}

package/dist/esm/plotly/basic-chart/helpers.js

@@ -0,0 +1,107 @@
+export const chartTypeToPlotlyType = (type) => {
+    switch (type) {
+        case "column":
+            return "bar";
+        case "line":
+            return "scatter";
+        case "area":
+            return "scatter";
+        case "bar":
+            return "bar";
+        case "pie":
+            return "pie";
+        case "treemap":
+            return "treemap";
+        case "sunburst":
+            return "sunburst";
+        case "bubble":
+            return "scatter";
+        case "scatter":
+            return "scatter";
+        case "histogram":
+            return "histogram";
+        case "boxplot":
+            return "box";
+        // Radar maps to plotly's polar scatter trace; the caller also sets a
+        // `polar` layout block. See basic-chart.tsx.
+        case "radar":
+            return "scatterpolar";
+        // Stock is rendered "line-derived" — each price role becomes its own
+        // scatter line trace. See basic-chart.tsx.
+        case "stock":
+            return "scatter";
+        case "waterfall":
+            return "waterfall";
+        case "funnel":
+            return "funnel";
+        // Combo defaults to bar; per-series seriesChartType overrides each
+        // trace independently. See chart-editor "Series type" selector.
+        case "combo":
+            return "bar";
+        // Region map (filled map) — plotly's built-in choropleth trace
+        // (plotly ships its own world geometry). See basic-chart.tsx.
+        case "regionMap":
+            return "choropleth";
+        default:
+            return "scatter";
+    }
+};
+export const getPlotlyTraceStyle = (type) => {
+    switch (type) {
+        case "line":
+            return { mode: "lines" };
+        case "area":
+            return { mode: "lines", fill: "tozeroy" };
+        // Stock price roles render as plain lines.
+        case "stock":
+            return { mode: "lines" };
+        default:
+            return {};
+    }
+};
+/**
+ * Map OOXML `<c:marker><c:symbol val=…>` to plotly marker symbol names.
+ * OOXML symbols don't all have direct plotly equivalents — closest
+ * visual analog is used.
+ */
+export const mapMarkerSymbolToPlotly = (symbol) => {
+    switch (symbol) {
+        case "circle":
+        case "dot":
+            return "circle";
+        case "square":
+            return "square";
+        case "diamond":
+            return "diamond";
+        case "triangle":
+            return "triangle-up";
+        case "x":
+            return "x";
+        case "plus":
+            return "cross";
+        case "star":
+            return "star";
+        case "dash":
+            return "line-ew";
+        case "auto":
+        case undefined:
+        case null:
+            return undefined;
+        default:
+            return undefined;
+    }
+};
+export const showXAxis = (type) => {
+    if (type === "line" ||
+        type === "area" ||
+        type === "bar" ||
+        type === "column" ||
+        type === "bubble" ||
+        type === "histogram" ||
+        // Stock is line-derived on a category x-axis. Radar is polar and
+        // does not use the cartesian x-axis.
+        type === "stock") {
+        return true;
+    }
+    return false;
+};

package/dist/esm/plotly/basic-chart/index.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import type { EChartComponentProps } from "../../types";
+export declare const ChartComponent: (props: EChartComponentProps) => React.JSX.Element;
+export default ChartComponent;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/plotly/basic-chart/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../plotly/basic-chart/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGxD,eAAO,MAAM,cAAc,GAAI,OAAO,oBAAoB,sBAMzD,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/esm/plotly/basic-chart/index.js

@@ -0,0 +1,7 @@
+import React from "react";
+import { BasicChart } from "./basic-chart";
+export const ChartComponent = (props) => {
+    return (React.createElement("div", { className: "shadow-lg bg-rnc-background flex-1 flex break-words flex-col" },
+        React.createElement(BasicChart, { ...props })));
+};
+export default ChartComponent;

package/dist/esm/tsconfig.esm.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../../config.ts","../../echarts-gl.d.ts","../../geo-modules.d.ts","../../index.ts","../../types.ts","../../vitest.config.ts","../../atoms/editing-chart.atom.ts","../../basic-chart/basic-chart.tsx","../../basic-chart/helpers.ts","../../basic-chart/index.tsx","../../components/dialogs/chart-editor-dialog.tsx","../../components/editors/chart-editor.tsx","../../components/editors/chart-range-input.tsx","../../hooks/use-chart-editor.ts","../../hooks/use-charts.ts","../../hooks/use-on-create-chart.ts","../../hooks/use-on-delete-chart.ts","../../hooks/use-on-move-chart.ts","../../hooks/use-on-resize-chart.ts","../../hooks/use-on-update-chart.ts","../../interface/create-chart.ts","../../interface/delete-chart.ts","../../interface/move-chart.ts","../../interface/resize-chart.ts","../../interface/update-chart.ts","../../plotly/basic-chart/basic-chart.tsx","../../plotly/basic-chart/helpers.ts","../../plotly/basic-chart/index.tsx","../../utils/aggregation.ts","../../utils/bar-layout.ts","../../utils/boxplot.ts","../../utils/bubble.ts","../../utils/chart-spec-utils.ts","../../utils/echarts-gl-loader.ts","../../utils/error-bars.ts","../../utils/gradient.ts","../../utils/hierarchy.ts","../../utils/histogram.ts","../../utils/of-pie.ts","../../utils/overrides.ts","../../utils/radar.ts","../../utils/region-map-loader.ts","../../utils/region-map.ts","../../utils/stock.ts","../../utils/three-d.ts","../../utils/trendline.ts","../../utils/waterfall.ts","../../utils/webgl.ts"],"version":"5.8.3"}

package/dist/esm/types.d.ts

@@ -0,0 +1,27 @@
+import type { ChartComponentProps, EmbeddedChart } from "@rowsncolumns/spreadsheet";
+import type { useCalculation } from "@rowsncolumns/spreadsheet-state";
+import type { useSpreadsheetState } from "@rowsncolumns/spreadsheet-state";
+export type EChartComponentProps = ChartComponentProps & {
+    /**
+     * Dark mode
+     */
+    isDarkMode?: boolean;
+    /**
+     * Get all formatted values from a domain
+     */
+    getDomainValuesFromRange: ReturnType<typeof useSpreadsheetState>["getDomainValuesFromRange"];
+    /**
+     * Get all effective values from a series
+     */
+    getSeriesValuesFromRange: ReturnType<typeof useSpreadsheetState>["getSeriesValuesFromRange"];
+    /**
+     * Request edit chart
+     * @param chart
+     */
+    onRequestEdit?(chart: EmbeddedChart): void;
+    /**
+     * Callback to trigger a calculation request
+     */
+    onRequestCalculate: ReturnType<typeof useCalculation>["onRequestCalculate"];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,aAAa,EACd,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAE3E,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,GAAG;IACvD;;OAEG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;OAEG;IACH,wBAAwB,EAAE,UAAU,CAClC,OAAO,mBAAmB,CAC3B,CAAC,0BAA0B,CAAC,CAAC;IAC9B;;OAEG;IACH,wBAAwB,EAAE,UAAU,CAClC,OAAO,mBAAmB,CAC3B,CAAC,0BAA0B,CAAC,CAAC;IAC9B;;;OAGG;IACH,aAAa,CAAC,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;IAC3C;;OAEG;IACH,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;CAC7E,CAAC"}

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,6 @@
+import type { ChartAggregateType, ChartData } from "@rowsncolumns/spreadsheet";
+export declare const sanitizeDomainValues: (values: (string | number | null | undefined)[]) => string[];
+export declare const shouldAggregateSeries: (series?: ChartData[]) => boolean;
+export declare const getDomainValuesForAxis: (domainValues: string[], aggregate: boolean) => string[];
+export declare const aggregateSeriesByDomain: (rawDomainValues: string[], seriesValues: (string | number | boolean | undefined)[], aggregateType: ChartAggregateType, orderedDomainValues: string[]) => (number | null)[];
+//# sourceMappingURL=aggregation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregation.d.ts","sourceRoot":"","sources":["../../../utils/aggregation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,SAAS,EACV,MAAM,2BAA2B,CAAC;AA0EnC,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,KAC7C,MAAM,EAA+B,CAAC;AAEzC,eAAO,MAAM,qBAAqB,GAAI,SAAS,SAAS,EAAE,KAAG,OAM5D,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,cAAc,MAAM,EAAE,EACtB,WAAW,OAAO,aACyC,CAAC;AAE9D,eAAO,MAAM,uBAAuB,GAClC,iBAAiB,MAAM,EAAE,EACzB,cAAc,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,EAAE,EACvD,eAAe,kBAAkB,EACjC,qBAAqB,MAAM,EAAE,KAC5B,CAAC,MAAM,GAAG,IAAI,CAAC,EA8BjB,CAAC"}

package/dist/esm/utils/aggregation.js

@@ -0,0 +1,96 @@
+const toDomainLabel = (value) => {
+    if (value === null || value === undefined) {
+        return "";
+    }
+    return String(value);
+};
+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 : undefined;
+    }
+    if (typeof value === "boolean") {
+        return value ? 1 : 0;
+    }
+    return undefined;
+};
+const uniqueDomains = (values) => {
+    const seen = new Set();
+    const ordered = [];
+    for (const value of values) {
+        if (!seen.has(value)) {
+            seen.add(value);
+            ordered.push(value);
+        }
+    }
+    return ordered;
+};
+const median = (values) => {
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        return (sorted[mid - 1] + sorted[mid]) / 2;
+    }
+    return sorted[mid];
+};
+const aggregateValues = (values, aggregateType) => {
+    if (values.length === 0) {
+        return null;
+    }
+    switch (aggregateType) {
+        case "SUM":
+            return values.reduce((total, value) => total + value, 0);
+        case "AVERAGE": {
+            const sum = values.reduce((total, value) => total + value, 0);
+            return sum / values.length;
+        }
+        case "COUNT":
+            return values.length;
+        case "MAX":
+            return Math.max(...values);
+        case "MIN":
+            return Math.min(...values);
+        case "MEDIAN":
+            return median(values);
+        default:
+            return null;
+    }
+};
+export const sanitizeDomainValues = (values) => values.map(toDomainLabel);
+export const shouldAggregateSeries = (series) => {
+    if (!series || series.length === 0) {
+        return false;
+    }
+    return series.every((item) => !!item.aggregateType);
+};
+export const getDomainValuesForAxis = (domainValues, aggregate) => (aggregate ? uniqueDomains(domainValues) : domainValues);
+export const aggregateSeriesByDomain = (rawDomainValues, seriesValues, aggregateType, orderedDomainValues) => {
+    const grouped = new Map();
+    for (const domain of orderedDomainValues) {
+        grouped.set(domain, []);
+    }
+    rawDomainValues.forEach((domainValue, index) => {
+        const currentGroup = grouped.get(domainValue);
+        if (!currentGroup) {
+            return;
+        }
+        if (aggregateType === "COUNT") {
+            const source = seriesValues[index];
+            if (source !== undefined && source !== null && source !== "") {
+                currentGroup.push(1);
+            }
+            return;
+        }
+        const numericValue = toNumericValue(seriesValues[index]);
+        if (numericValue !== undefined) {
+            currentGroup.push(numericValue);
+        }
+    });
+    return orderedDomainValues.map((domain) => {
+        const values = grouped.get(domain) ?? [];
+        return aggregateValues(values, aggregateType);
+    });
+};

package/dist/esm/utils/bar-layout.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Bar/column layout mapping — Excel `<c:overlap>` / `<c:gapWidth>` to
+ * echarts `barGap` / `barCategoryGap`.
+ *
+ * Excel semantics:
+ * - `overlap` (-100..100): how much adjacent bars *within* a category
+ *   cluster overlap, as a percentage of one bar's width. 100 = bars
+ *   fully stacked on the same X slot, 0 = side-by-side touching,
+ *   -100 = a full bar-width gap between them.
+ * - `gapWidth` (0..500): the gap *between* category clusters, as a
+ *   percentage of one bar's width. Excel default is 150.
+ *
+ * echarts semantics:
+ * - `barGap` ("<p>%"): gap between bars of different series in the same
+ *   category, as a percentage of the bar width. Negative values overlap
+ *   ("-100%" = fully overlapped).
+ * - `barCategoryGap` ("<p>%"): the gap reserved for each category slot,
+ *   as a percentage of the *band width* (the whole category slot), i.e.
+ *   `barWidth = (band - categoryGap) / (n + (n - 1) * barGapPercent)`.
+ */
+type MaybeNumber = number | null | undefined;
+/**
+ * Map Excel series overlap (-100..100) to an echarts `barGap`
+ * percentage string.
+ *
+ * Both express the same quantity in bar-width units with opposite
+ * sign conventions (Excel measures overlap, echarts measures gap), so
+ * the mapping is a negation:
+ *   overlap 100  → barGap "-100%" (fully overlapped)
+ *   overlap 0    → barGap "0%"    (touching)
+ *   overlap -100 → barGap "100%"  (one bar-width gap)
+ *
+ * Returns undefined when overlap is unset so echarts keeps its own
+ * default ("30%").
+ */
+export declare const overlapToBarGap: (overlap?: MaybeNumber) => string | undefined;
+/**
+ * Map Excel `gapWidth` (0..500, % of bar width) to an echarts
+ * `barCategoryGap` percentage string (% of the category band width).
+ *
+ * Derivation — measure the whole band in bar-width units:
+ *   bars + in-cluster gaps: n - (n - 1) * overlap / 100
+ *   category gap:           gapWidth / 100
+ * so the gap's share of the band is
+ *   gapWidth / (100 * n - (n - 1) * overlap + gapWidth)
+ * e.g. one series with the Excel default gapWidth=150 → 150/250 = "60%".
+ *
+ * `seriesCount` is the number of side-by-side bars per category (1 for
+ * stacked charts, where all series share one slot). Returns undefined
+ * when gapWidth is unset so echarts keeps its default ("20%").
+ */
+export declare const gapWidthToBarCategoryGap: (gapWidth?: MaybeNumber, options?: {
+    seriesCount?: number;
+    overlap?: MaybeNumber;
+}) => string | undefined;
+export {};
+//# sourceMappingURL=bar-layout.d.ts.map

package/dist/esm/utils/bar-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bar-layout.d.ts","sourceRoot":"","sources":["../../../utils/bar-layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,KAAK,WAAW,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;AAQ7C;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,WAAW,KAAG,MAAM,GAAG,SAGhE,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB,GACnC,WAAW,WAAW,EACtB,UAAS;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,WAAW,CAAA;CAAO,KAC5D,MAAM,GAAG,SAWX,CAAC"}

package/dist/esm/utils/bar-layout.js

@@ -0,0 +1,70 @@
+/**
+ * Bar/column layout mapping — Excel `<c:overlap>` / `<c:gapWidth>` to
+ * echarts `barGap` / `barCategoryGap`.
+ *
+ * Excel semantics:
+ * - `overlap` (-100..100): how much adjacent bars *within* a category
+ *   cluster overlap, as a percentage of one bar's width. 100 = bars
+ *   fully stacked on the same X slot, 0 = side-by-side touching,
+ *   -100 = a full bar-width gap between them.
+ * - `gapWidth` (0..500): the gap *between* category clusters, as a
+ *   percentage of one bar's width. Excel default is 150.
+ *
+ * echarts semantics:
+ * - `barGap` ("<p>%"): gap between bars of different series in the same
+ *   category, as a percentage of the bar width. Negative values overlap
+ *   ("-100%" = fully overlapped).
+ * - `barCategoryGap` ("<p>%"): the gap reserved for each category slot,
+ *   as a percentage of the *band width* (the whole category slot), i.e.
+ *   `barWidth = (band - categoryGap) / (n + (n - 1) * barGapPercent)`.
+ */
+const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+/**
+ * Map Excel series overlap (-100..100) to an echarts `barGap`
+ * percentage string.
+ *
+ * Both express the same quantity in bar-width units with opposite
+ * sign conventions (Excel measures overlap, echarts measures gap), so
+ * the mapping is a negation:
+ *   overlap 100  → barGap "-100%" (fully overlapped)
+ *   overlap 0    → barGap "0%"    (touching)
+ *   overlap -100 → barGap "100%"  (one bar-width gap)
+ *
+ * Returns undefined when overlap is unset so echarts keeps its own
+ * default ("30%").
+ */
+export const overlapToBarGap = (overlap) => {
+    if (!isFiniteNumber(overlap))
+        return undefined;
+    return `${-clamp(overlap, -100, 100)}%`;
+};
+/**
+ * Map Excel `gapWidth` (0..500, % of bar width) to an echarts
+ * `barCategoryGap` percentage string (% of the category band width).
+ *
+ * Derivation — measure the whole band in bar-width units:
+ *   bars + in-cluster gaps: n - (n - 1) * overlap / 100
+ *   category gap:           gapWidth / 100
+ * so the gap's share of the band is
+ *   gapWidth / (100 * n - (n - 1) * overlap + gapWidth)
+ * e.g. one series with the Excel default gapWidth=150 → 150/250 = "60%".
+ *
+ * `seriesCount` is the number of side-by-side bars per category (1 for
+ * stacked charts, where all series share one slot). Returns undefined
+ * when gapWidth is unset so echarts keeps its default ("20%").
+ */
+export const gapWidthToBarCategoryGap = (gapWidth, options = {}) => {
+    if (!isFiniteNumber(gapWidth))
+        return undefined;
+    const gap = clamp(gapWidth, 0, 500);
+    const seriesCount = Math.max(1, Math.floor(options.seriesCount ?? 1));
+    const overlap = isFiniteNumber(options.overlap)
+        ? clamp(options.overlap, -100, 100)
+        : 0;
+    const band = 100 * seriesCount - (seriesCount - 1) * overlap + gap;
+    if (band <= 0)
+        return undefined;
+    const percent = (100 * gap) / band;
+    return `${Math.round(percent * 100) / 100}%`;
+};

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

@@ -0,0 +1,62 @@
+/**
+ * Box-and-whisker statistics shared by chart renderers.
+ *
+ * Plotly's box trace computes quartiles itself from raw values.
+ * Echarts' boxplot series requires pre-computed [min, Q1, median, Q3, max]
+ * tuples per box; this helper produces that shape.
+ */
+export type BoxplotStats = [number, number, number, number, number];
+/**
+ * Quartile computation method, mirroring Excel's box & whisker
+ * "quartile calculation" option:
+ *   - "inclusive" — QUARTILE.INC: linear interpolation over positions
+ *     `(n - 1) * q` (median included in both halves).
+ *   - "exclusive" — QUARTILE.EXC: linear interpolation over positions
+ *     `(n + 1) * q` (median excluded), Tukey-style hinges.
+ */
+export type QuartileMethod = "inclusive" | "exclusive";
+/**
+ * QUARTILE.INC — linear interpolation at position `(n - 1) * q`
+ * (0-indexed). Identical to the interpolation echarts' built-in
+ * boxplot transform uses.
+ */
+export declare const quartileInc: (sorted: number[], q: number) => number;
+/**
+ * QUARTILE.EXC — linear interpolation at 1-indexed position
+ * `(n + 1) * q`. Excel returns #NUM! when the position falls outside
+ * `[1, n]` (tiny samples); for charting we clamp to the nearest order
+ * statistic instead so every box still renders.
+ */
+export declare const quartileExc: (sorted: number[], q: number) => number;
+/**
+ * Full box-and-whisker summary. Quartiles follow the requested method
+ * ("inclusive" when omitted — the same interpolation
+ * `computeBoxplotStats` has always used). Outliers are points beyond
+ * the Tukey fences `Q1 - 1.5×IQR` / `Q3 + 1.5×IQR`; the whisker ends
+ * are the most extreme data points still inside the fences (Excel's
+ * behavior when "show outlier points" is on).
+ */
+export type BoxplotSummary = {
+    min: number;
+    q1: number;
+    median: number;
+    q3: number;
+    max: number;
+    mean: number;
+    /** Smallest data point >= Q1 - 1.5×IQR. */
+    lowerWhisker: number;
+    /** Largest data point <= Q3 + 1.5×IQR. */
+    upperWhisker: number;
+    /** Data points outside the 1.5×IQR fences, ascending. */
+    outliers: number[];
+};
+export declare const computeBoxplotSummary: (values: (number | null | undefined)[], options?: {
+    quartileMethod?: QuartileMethod | null;
+}) => BoxplotSummary | null;
+/**
+ * Compute [min, Q1, median, Q3, max] using linear interpolation between
+ * order statistics — matches echarts' built-in `dataset.transform: 'boxplot'`
+ * behavior.
+ */
+export declare const computeBoxplotStats: (values: (number | null | undefined)[]) => BoxplotStats | null;
+//# sourceMappingURL=boxplot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boxplot.d.ts","sourceRoot":"","sources":["../../../utils/boxplot.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAEpE;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,WAAW,CAAC;AAUvD;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,EAAE,EAAE,GAAG,MAAM,KAAG,MACrC,CAAC;AAEtB;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,EAAE,EAAE,GAAG,MAAM,KAAG,MAQzD,CAAC;AAeF;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,YAAY,EAAE,MAAM,CAAC;IACrB,0CAA0C;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,yDAAyD;IACzD,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,QAAQ,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACrC,UAAU;IAAE,cAAc,CAAC,EAAE,cAAc,GAAG,IAAI,CAAA;CAAE,KACnD,cAAc,GAAG,IA0BnB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,KACpC,YAAY,GAAG,IAejB,CAAC"}

package/dist/esm/utils/boxplot.js

@@ -0,0 +1,91 @@
+/**
+ * Box-and-whisker statistics shared by chart renderers.
+ *
+ * Plotly's box trace computes quartiles itself from raw values.
+ * Echarts' boxplot series requires pre-computed [min, Q1, median, Q3, max]
+ * tuples per box; this helper produces that shape.
+ */
+const quantile = (sorted, q) => {
+    const idx = (sorted.length - 1) * q;
+    const lo = Math.floor(idx);
+    const hi = Math.ceil(idx);
+    if (lo === hi)
+        return sorted[lo];
+    return sorted[lo] + (sorted[hi] - sorted[lo]) * (idx - lo);
+};
+/**
+ * QUARTILE.INC — linear interpolation at position `(n - 1) * q`
+ * (0-indexed). Identical to the interpolation echarts' built-in
+ * boxplot transform uses.
+ */
+export const quartileInc = (sorted, q) => quantile(sorted, q);
+/**
+ * QUARTILE.EXC — linear interpolation at 1-indexed position
+ * `(n + 1) * q`. Excel returns #NUM! when the position falls outside
+ * `[1, n]` (tiny samples); for charting we clamp to the nearest order
+ * statistic instead so every box still renders.
+ */
+export const quartileExc = (sorted, q) => {
+    const n = sorted.length;
+    const pos = (n + 1) * q; // 1-indexed
+    if (pos <= 1)
+        return sorted[0];
+    if (pos >= n)
+        return sorted[n - 1];
+    const lo = Math.floor(pos);
+    const frac = pos - lo;
+    return sorted[lo - 1] + (sorted[lo] - sorted[lo - 1]) * frac;
+};
+const quartile = (sorted, q, method) => method === "exclusive" ? quartileExc(sorted, q) : quartileInc(sorted, q);
+const toSortedNumeric = (values) => values
+    .filter((v) => typeof v === "number" && Number.isFinite(v))
+    .slice()
+    .sort((a, b) => a - b);
+export const computeBoxplotSummary = (values, options) => {
+    const numeric = toSortedNumeric(values);
+    if (numeric.length === 0)
+        return null;
+    const method = options?.quartileMethod ?? "inclusive";
+    const q1 = quartile(numeric, 0.25, method);
+    const median = quartile(numeric, 0.5, method);
+    const q3 = quartile(numeric, 0.75, method);
+    const iqr = q3 - q1;
+    const lowerFence = q1 - 1.5 * iqr;
+    const upperFence = q3 + 1.5 * iqr;
+    const inliers = numeric.filter((v) => v >= lowerFence && v <= upperFence);
+    const outliers = numeric.filter((v) => v < lowerFence || v > upperFence);
+    const mean = numeric.reduce((sum, v) => sum + v, 0) / numeric.length;
+    return {
+        min: numeric[0],
+        q1,
+        median,
+        q3,
+        max: numeric[numeric.length - 1],
+        mean,
+        // Degenerate fences (all points outliers) can't happen — Q1/Q3 are
+        // always inside [min, max] — so inliers is never empty.
+        lowerWhisker: inliers[0],
+        upperWhisker: inliers[inliers.length - 1],
+        outliers,
+    };
+};
+/**
+ * Compute [min, Q1, median, Q3, max] using linear interpolation between
+ * order statistics — matches echarts' built-in `dataset.transform: 'boxplot'`
+ * behavior.
+ */
+export const computeBoxplotStats = (values) => {
+    const numeric = values
+        .filter((v) => typeof v === "number" && Number.isFinite(v))
+        .slice()
+        .sort((a, b) => a - b);
+    if (numeric.length === 0)
+        return null;
+    return [
+        numeric[0],
+        quantile(numeric, 0.25),
+        quantile(numeric, 0.5),
+        quantile(numeric, 0.75),
+        numeric[numeric.length - 1],
+    ];
+};

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

@@ -0,0 +1,52 @@
+export declare const toLabelString: (value: unknown) => string;
+export declare const toNumericValue: (value: unknown) => number | null;
+export declare const createBubbleSizeScale: (values: number[]) => (value: number) => number;
+export type BubbleSeriesInput = {
+    name?: string | null;
+    values: (string | number | boolean | null | undefined)[];
+    /**
+     * Per-series X values. Excel's scatter charts always carry per-series
+     * `xVal` (each series has its own x/y pair). Excel's bubble charts
+     * typically share an X axis but the OOXML format allows per-series.
+     * When omitted, the shared `xValues` arg on `PrepareBubbleSeriesArgs`
+     * is used — preserves the old shared-X behaviour for fixtures that
+     * pass a single domain.
+     */
+    xValues?: (string | number | boolean | null | undefined)[];
+    /**
+     * Per-series bubble sizes. Bubble charts may carry one `bubbleSize`
+     * per series; falls back to the shared `sizeValues` when omitted.
+     */
+    sizeValues?: (string | number | boolean | null | undefined)[];
+};
+export type BubbleSeriesPoint = {
+    value: [number, number, number];
+    name: string;
+    xLabel?: string;
+};
+export type PreparedBubbleSeries = {
+    name: string;
+    points: BubbleSeriesPoint[];
+};
+export type PrepareBubbleSeriesArgs = {
+    /**
+     * Shared X values across all series. Used as the fallback when a
+     * series doesn't carry its own `xValues`. For pure-scatter charts
+     * (per-series xVal) this is typically `[]` and each series provides
+     * its own.
+     */
+    xValues: (string | number | boolean | null | undefined)[];
+    labelValues: (string | number | boolean | null | undefined)[];
+    /**
+     * Shared size values. Same fallback semantics as `xValues`.
+     */
+    sizeValues: (string | number | boolean | null | undefined)[];
+    series: BubbleSeriesInput[];
+};
+export type BubbleSeriesResult = {
+    categories: string[];
+    series: PreparedBubbleSeries[];
+    sizeValues: number[];
+};
+export declare const prepareBubbleSeriesData: ({ xValues, labelValues, sizeValues, series, }: PrepareBubbleSeriesArgs) => BubbleSeriesResult;
+//# sourceMappingURL=bubble.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bubble.d.ts","sourceRoot":"","sources":["../../../utils/bubble.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,MACU,CAAC;AAE1D,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,KAAG,MAAM,GAAG,IAYxD,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,QAAQ,MAAM,EAAE,aAQrC,MAAM,WAOtB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC;IACzD;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC;IAC3D;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC;CAC/D,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,iBAAiB,EAAE,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC;;;;;OAKG;IACH,OAAO,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC;IAC1D,WAAW,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC;IAC9D;;OAEG;IACH,UAAU,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC;IAC7D,MAAM,EAAE,iBAAiB,EAAE,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,oBAAoB,EAAE,CAAC;IAC/B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAwCF,eAAO,MAAM,uBAAuB,GAAI,+CAKrC,uBAAuB,KAAG,kBAsF5B,CAAC"}