@rowsncolumns/charts 27.0.30

package/dist/cjs/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/cjs/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/cjs/plotly/basic-chart/helpers.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showXAxis = exports.mapMarkerSymbolToPlotly = exports.getPlotlyTraceStyle = exports.chartTypeToPlotlyType = void 0;
+var chartTypeToPlotlyType = function (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";
+    }
+};
+exports.chartTypeToPlotlyType = chartTypeToPlotlyType;
+var getPlotlyTraceStyle = function (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 {};
+    }
+};
+exports.getPlotlyTraceStyle = getPlotlyTraceStyle;
+/**
+ * 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.
+ */
+var mapMarkerSymbolToPlotly = function (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;
+    }
+};
+exports.mapMarkerSymbolToPlotly = mapMarkerSymbolToPlotly;
+var showXAxis = function (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;
+};
+exports.showXAxis = showXAxis;

package/dist/cjs/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/cjs/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/cjs/plotly/basic-chart/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChartComponent = void 0;
+var tslib_1 = require("tslib");
+var react_1 = tslib_1.__importDefault(require("react"));
+var basic_chart_1 = require("./basic-chart");
+var ChartComponent = function (props) {
+    return (react_1.default.createElement("div", { className: "shadow-lg bg-rnc-background flex-1 flex break-words flex-col" },
+        react_1.default.createElement(basic_chart_1.BasicChart, tslib_1.__assign({}, props))));
+};
+exports.ChartComponent = ChartComponent;
+exports.default = exports.ChartComponent;

package/dist/cjs/tsconfig.cjs.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/cjs/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/cjs/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/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/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/cjs/utils/aggregation.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateSeriesByDomain = exports.getDomainValuesForAxis = exports.shouldAggregateSeries = exports.sanitizeDomainValues = void 0;
+var tslib_1 = require("tslib");
+var toDomainLabel = function (value) {
+    if (value === null || value === undefined) {
+        return "";
+    }
+    return String(value);
+};
+var toNumericValue = function (value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string") {
+        var parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    if (typeof value === "boolean") {
+        return value ? 1 : 0;
+    }
+    return undefined;
+};
+var uniqueDomains = function (values) {
+    var e_1, _a;
+    var seen = new Set();
+    var ordered = [];
+    try {
+        for (var values_1 = tslib_1.__values(values), values_1_1 = values_1.next(); !values_1_1.done; values_1_1 = values_1.next()) {
+            var value = values_1_1.value;
+            if (!seen.has(value)) {
+                seen.add(value);
+                ordered.push(value);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (values_1_1 && !values_1_1.done && (_a = values_1.return)) _a.call(values_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return ordered;
+};
+var median = function (values) {
+    var sorted = tslib_1.__spreadArray([], tslib_1.__read(values), false).sort(function (a, b) { return a - b; });
+    var mid = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        return (sorted[mid - 1] + sorted[mid]) / 2;
+    }
+    return sorted[mid];
+};
+var aggregateValues = function (values, aggregateType) {
+    if (values.length === 0) {
+        return null;
+    }
+    switch (aggregateType) {
+        case "SUM":
+            return values.reduce(function (total, value) { return total + value; }, 0);
+        case "AVERAGE": {
+            var sum = values.reduce(function (total, value) { return total + value; }, 0);
+            return sum / values.length;
+        }
+        case "COUNT":
+            return values.length;
+        case "MAX":
+            return Math.max.apply(Math, tslib_1.__spreadArray([], tslib_1.__read(values), false));
+        case "MIN":
+            return Math.min.apply(Math, tslib_1.__spreadArray([], tslib_1.__read(values), false));
+        case "MEDIAN":
+            return median(values);
+        default:
+            return null;
+    }
+};
+var sanitizeDomainValues = function (values) { return values.map(toDomainLabel); };
+exports.sanitizeDomainValues = sanitizeDomainValues;
+var shouldAggregateSeries = function (series) {
+    if (!series || series.length === 0) {
+        return false;
+    }
+    return series.every(function (item) { return !!item.aggregateType; });
+};
+exports.shouldAggregateSeries = shouldAggregateSeries;
+var getDomainValuesForAxis = function (domainValues, aggregate) { return (aggregate ? uniqueDomains(domainValues) : domainValues); };
+exports.getDomainValuesForAxis = getDomainValuesForAxis;
+var aggregateSeriesByDomain = function (rawDomainValues, seriesValues, aggregateType, orderedDomainValues) {
+    var e_2, _a;
+    var grouped = new Map();
+    try {
+        for (var orderedDomainValues_1 = tslib_1.__values(orderedDomainValues), orderedDomainValues_1_1 = orderedDomainValues_1.next(); !orderedDomainValues_1_1.done; orderedDomainValues_1_1 = orderedDomainValues_1.next()) {
+            var domain = orderedDomainValues_1_1.value;
+            grouped.set(domain, []);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (orderedDomainValues_1_1 && !orderedDomainValues_1_1.done && (_a = orderedDomainValues_1.return)) _a.call(orderedDomainValues_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    rawDomainValues.forEach(function (domainValue, index) {
+        var currentGroup = grouped.get(domainValue);
+        if (!currentGroup) {
+            return;
+        }
+        if (aggregateType === "COUNT") {
+            var source = seriesValues[index];
+            if (source !== undefined && source !== null && source !== "") {
+                currentGroup.push(1);
+            }
+            return;
+        }
+        var numericValue = toNumericValue(seriesValues[index]);
+        if (numericValue !== undefined) {
+            currentGroup.push(numericValue);
+        }
+    });
+    return orderedDomainValues.map(function (domain) {
+        var _a;
+        var values = (_a = grouped.get(domain)) !== null && _a !== void 0 ? _a : [];
+        return aggregateValues(values, aggregateType);
+    });
+};
+exports.aggregateSeriesByDomain = aggregateSeriesByDomain;

package/dist/cjs/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/cjs/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/cjs/utils/bar-layout.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * 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)`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gapWidthToBarCategoryGap = exports.overlapToBarGap = void 0;
+var clamp = function (value, min, max) {
+    return Math.max(min, Math.min(max, value));
+};
+var isFiniteNumber = function (value) {
+    return 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%").
+ */
+var overlapToBarGap = function (overlap) {
+    if (!isFiniteNumber(overlap))
+        return undefined;
+    return "".concat(-clamp(overlap, -100, 100), "%");
+};
+exports.overlapToBarGap = overlapToBarGap;
+/**
+ * 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%").
+ */
+var gapWidthToBarCategoryGap = function (gapWidth, options) {
+    var _a;
+    if (options === void 0) { options = {}; }
+    if (!isFiniteNumber(gapWidth))
+        return undefined;
+    var gap = clamp(gapWidth, 0, 500);
+    var seriesCount = Math.max(1, Math.floor((_a = options.seriesCount) !== null && _a !== void 0 ? _a : 1));
+    var overlap = isFiniteNumber(options.overlap)
+        ? clamp(options.overlap, -100, 100)
+        : 0;
+    var band = 100 * seriesCount - (seriesCount - 1) * overlap + gap;
+    if (band <= 0)
+        return undefined;
+    var percent = (100 * gap) / band;
+    return "".concat(Math.round(percent * 100) / 100, "%");
+};
+exports.gapWidthToBarCategoryGap = gapWidthToBarCategoryGap;

package/dist/cjs/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/cjs/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/cjs/utils/boxplot.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeBoxplotStats = exports.computeBoxplotSummary = exports.quartileExc = exports.quartileInc = void 0;
+var quantile = function (sorted, q) {
+    var idx = (sorted.length - 1) * q;
+    var lo = Math.floor(idx);
+    var 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.
+ */
+var quartileInc = function (sorted, q) {
+    return quantile(sorted, q);
+};
+exports.quartileInc = quartileInc;
+/**
+ * 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.
+ */
+var quartileExc = function (sorted, q) {
+    var n = sorted.length;
+    var pos = (n + 1) * q; // 1-indexed
+    if (pos <= 1)
+        return sorted[0];
+    if (pos >= n)
+        return sorted[n - 1];
+    var lo = Math.floor(pos);
+    var frac = pos - lo;
+    return sorted[lo - 1] + (sorted[lo] - sorted[lo - 1]) * frac;
+};
+exports.quartileExc = quartileExc;
+var quartile = function (sorted, q, method) {
+    return method === "exclusive" ? (0, exports.quartileExc)(sorted, q) : (0, exports.quartileInc)(sorted, q);
+};
+var toSortedNumeric = function (values) {
+    return values
+        .filter(function (v) { return typeof v === "number" && Number.isFinite(v); })
+        .slice()
+        .sort(function (a, b) { return a - b; });
+};
+var computeBoxplotSummary = function (values, options) {
+    var _a;
+    var numeric = toSortedNumeric(values);
+    if (numeric.length === 0)
+        return null;
+    var method = (_a = options === null || options === void 0 ? void 0 : options.quartileMethod) !== null && _a !== void 0 ? _a : "inclusive";
+    var q1 = quartile(numeric, 0.25, method);
+    var median = quartile(numeric, 0.5, method);
+    var q3 = quartile(numeric, 0.75, method);
+    var iqr = q3 - q1;
+    var lowerFence = q1 - 1.5 * iqr;
+    var upperFence = q3 + 1.5 * iqr;
+    var inliers = numeric.filter(function (v) { return v >= lowerFence && v <= upperFence; });
+    var outliers = numeric.filter(function (v) { return v < lowerFence || v > upperFence; });
+    var mean = numeric.reduce(function (sum, v) { return sum + v; }, 0) / numeric.length;
+    return {
+        min: numeric[0],
+        q1: q1,
+        median: median,
+        q3: q3,
+        max: numeric[numeric.length - 1],
+        mean: 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: outliers,
+    };
+};
+exports.computeBoxplotSummary = computeBoxplotSummary;
+/**
+ * Compute [min, Q1, median, Q3, max] using linear interpolation between
+ * order statistics — matches echarts' built-in `dataset.transform: 'boxplot'`
+ * behavior.
+ */
+var computeBoxplotStats = function (values) {
+    var numeric = values
+        .filter(function (v) { return typeof v === "number" && Number.isFinite(v); })
+        .slice()
+        .sort(function (a, b) { return 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],
+    ];
+};
+exports.computeBoxplotStats = computeBoxplotStats;