@rowsncolumns/charts 27.0.30

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

@@ -0,0 +1,141 @@
+/**
+ * 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.
+ */
+/** Excel's default split: the last 3 categories move to the second plot. */
+export const DEFAULT_OF_PIE_SPLIT_POS = 3;
+/** OOXML `<c:secondPieSize>` default — secondary plot is 75% of the main pie. */
+export const DEFAULT_SECOND_PIE_SIZE = 75;
+/** Label of the aggregated slice representing the secondary plot's total. */
+export const OF_PIE_OTHER_LABEL = "Other";
+const toFiniteNumber = (value) => {
+    const 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).
+ */
+export const normalizeOfPieSplitType = (raw) => {
+    switch (String(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";
+    }
+};
+/** Coerce `<c:ofPieType>`-ish input to "pie" | "bar" (default "pie"). */
+export const resolveOfPieType = (raw) => String(raw ?? "").toLowerCase() === "bar" ? "bar" : "pie";
+/** Clamp `<c:secondPieSize>` to its OOXML 5–200 range (default 75). */
+export const clampSecondPieSize = (raw) => {
+    const v = typeof raw === "number" && Number.isFinite(raw)
+        ? raw
+        : DEFAULT_SECOND_PIE_SIZE;
+    return Math.min(200, Math.max(5, v));
+};
+/**
+ * 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 const isOfPieChartSpec = (spec) => spec?.chartType === "pie" &&
+    (String(spec.sourceChartType ?? "").toUpperCase() === "OF_PIE" ||
+        spec.ofPieType === "pie" ||
+        spec.ofPieType === "bar");
+/**
+ * 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 const otherSliceHalfAngle = (otherTotal, total) => {
+    if (!(total > 0))
+        return 0;
+    const fraction = Math.min(1, Math.max(0, otherTotal / total));
+    return Math.PI * fraction;
+};
+/**
+ * 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 const splitOfPie = (values, labels, options) => {
+    const slices = (values ?? []).map((v, i) => ({
+        label: String(labels?.[i] ?? ""),
+        value: toFiniteNumber(v),
+    }));
+    const total = slices.reduce((sum, s) => sum + s.value, 0);
+    const splitType = normalizeOfPieSplitType(options?.splitType);
+    const splitPos = typeof options?.splitPos === "number" && Number.isFinite(options.splitPos)
+        ? options.splitPos
+        : DEFAULT_OF_PIE_SPLIT_POS;
+    const moved = slices.map(() => false);
+    if (slices.length > 1) {
+        if (splitType === "position") {
+            // Last N categories; the main pie keeps at least one real slice.
+            const n = Math.min(Math.max(Math.floor(splitPos), 0), slices.length - 1);
+            for (let i = slices.length - n; i < slices.length; i++) {
+                moved[i] = true;
+            }
+        }
+        else if (splitType === "value") {
+            slices.forEach((s, i) => {
+                if (s.value < splitPos)
+                    moved[i] = true;
+            });
+        }
+        else {
+            // percent — share of the grand total below splitPos%.
+            slices.forEach((s, i) => {
+                if (total > 0 && (s.value / total) * 100 < splitPos)
+                    moved[i] = true;
+            });
+        }
+    }
+    const main = [];
+    const secondary = [];
+    slices.forEach((s, i) => {
+        (moved[i] ? secondary : main).push(s);
+    });
+    const otherTotal = secondary.reduce((sum, s) => sum + s.value, 0);
+    if (secondary.length > 0) {
+        main.push({
+            label: options?.otherLabel ?? OF_PIE_OTHER_LABEL,
+            value: otherTotal,
+        });
+    }
+    return { main, secondary, otherTotal, total };
+};

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

@@ -0,0 +1,159 @@
+import { ssfFormat } from "@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`. */
+export const textFormatToEchartsTextStyle = (fmt) => {
+    if (!fmt)
+        return undefined;
+    const 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;
+};
+export const applyLegendOverrides = (legend, opts) => {
+    if (!opts)
+        return legend;
+    const next = { ...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;
+    }
+    const legendTextStyle = textFormatToEchartsTextStyle(opts.textFormat);
+    if (legendTextStyle) {
+        next.textStyle = { ...(next.textStyle ?? {}), ...legendTextStyle };
+    }
+    return next;
+};
+export const applyAxisOverrides = (axis, opts) => {
+    if (!opts)
+        return axis;
+    const next = { ...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 = { ...(next.splitLine ?? {}), show: false };
+    }
+    if (opts.showMajorGridlines === true) {
+        next.splitLine = { ...(next.splitLine ?? {}), show: true };
+    }
+    // Axis label text style (tick labels) + axis title font come from
+    // <c:txPr>. Without this echarts uses its default (~black on light).
+    const axisTextStyle = textFormatToEchartsTextStyle(opts.textFormat);
+    if (axisTextStyle) {
+        next.axisLabel = { ...(next.axisLabel ?? {}), ...axisTextStyle };
+        next.nameTextStyle = { ...(next.nameTextStyle ?? {}), ...axisTextStyle };
+    }
+    return next;
+};
+/**
+ * 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.
+ */
+const formatLabelValue = (rawValue, originalValue, pattern) => {
+    const target = originalValue ?? rawValue;
+    if (pattern) {
+        return ssfFormat(pattern, target);
+    }
+    return target === undefined || target === null ? "" : String(target);
+};
+export const dataLabelFormatter = (opts) => (params) => {
+    const 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(`${params.percent}%`);
+    }
+    const 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`.
+        const originalValue = typeof params.data === "object" && params.data
+            ? params.data.originalValue
+            : undefined;
+        parts.push(formatLabelValue(params.value, originalValue, opts.numberFormatPattern));
+    }
+    return parts.join(": ");
+};
+const ECHARTS_DLBL_POS = {
+    center: "inside",
+    inside: "inside",
+    outside: "outside",
+    insideEnd: "insideTop",
+    outsideEnd: "top",
+    bestFit: "top",
+};
+export const buildSeriesLabelOption = (opts) => {
+    if (!opts?.show)
+        return undefined;
+    const position = (opts.position && ECHARTS_DLBL_POS[opts.position]) ?? "top";
+    return {
+        show: true,
+        position,
+        formatter: dataLabelFormatter(opts),
+    };
+};

package/dist/esm/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/esm/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"}

package/dist/esm/utils/radar.js

@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+const isFiniteNum = (v) => typeof v === "number" && Number.isFinite(v);
+const toNumber = (v) => isFiniteNum(v) ? v : 0;
+/**
+ * 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 const buildRadarIndicators = (categories, series) => {
+    return categories.map((label, i) => {
+        let max = 0;
+        for (const s of series) {
+            const v = s.values[i];
+            if (isFiniteNum(v))
+                max = Math.max(max, v);
+        }
+        return {
+            name: String(label ?? ""),
+            // Pad by 10% so the outermost ring has breathing room; never 0.
+            max: max > 0 ? max * 1.1 : 1,
+        };
+    });
+};
+/**
+ * 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 const buildRadarSeriesData = (series, indicatorCount) => {
+    return series.map((s) => {
+        const value = [];
+        for (let i = 0; i < indicatorCount; i++) {
+            value.push(toNumber(s.values[i]));
+        }
+        return { value, name: s.name };
+    });
+};

package/dist/esm/utils/region-map-loader.d.ts

@@ -0,0 +1,22 @@
+export type RegionMapGeo = {
+    /** The map's region names — the match targets for data labels. */
+    regionNames: string[];
+};
+/**
+ * Host-provided geo data: register `geoJson` under `name` so region-map
+ * specs with `geoScope: name` can render on it (e.g. a US-states map).
+ * Region matching targets each feature's `properties.name`. The actual
+ * `echarts.registerMap` call is deferred until the map modules have
+ * loaded, so this is safe to call at module scope.
+ */
+export declare const registerChartGeoMap: (name: string, geoJson: object) => void;
+/**
+ * Resolve the geo data for a scope, loading the echarts map modules
+ * (and, for "world", the bundled world GeoJSON) on first use. Resolves
+ * null — never throws — when the scope is unknown or an asset failed
+ * to load; the renderer then draws an empty chart.
+ */
+export declare const loadRegionMapGeo: (scope: string) => Promise<RegionMapGeo | null>;
+/** Test hook — resets the module-level registries and latches. */
+export declare const __resetRegionMapLoaderForTests: () => void;
+//# sourceMappingURL=region-map-loader.d.ts.map

package/dist/esm/utils/region-map-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"region-map-loader.d.ts","sourceRoot":"","sources":["../../../utils/region-map-loader.ts"],"names":[],"mappings":"AAsCA,MAAM,MAAM,YAAY,GAAG;IACzB,kEAAkE;IAClE,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAmDF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,EAAE,SAAS,MAAM,KAAG,IAMnE,CAAC;AAkCF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAC3B,OAAO,MAAM,KACZ,OAAO,CAAC,YAAY,GAAG,IAAI,CAyB7B,CAAC;AAEF,kEAAkE;AAClE,eAAO,MAAM,8BAA8B,QAAO,IAKjD,CAAC"}