@rowsncolumns/charts 27.0.30

package/dist/cjs/utils/radar.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRadarSeriesData = exports.buildRadarIndicators = void 0;
+var tslib_1 = require("tslib");
+var isFiniteNum = function (v) {
+    return typeof v === "number" && Number.isFinite(v);
+};
+var toNumber = function (v) {
+    return 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.
+ */
+var buildRadarIndicators = function (categories, series) {
+    return categories.map(function (label, i) {
+        var e_1, _a;
+        var max = 0;
+        try {
+            for (var series_1 = tslib_1.__values(series), series_1_1 = series_1.next(); !series_1_1.done; series_1_1 = series_1.next()) {
+                var s = series_1_1.value;
+                var v = s.values[i];
+                if (isFiniteNum(v))
+                    max = Math.max(max, v);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (series_1_1 && !series_1_1.done && (_a = series_1.return)) _a.call(series_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return {
+            name: String(label !== null && label !== void 0 ? label : ""),
+            // Pad by 10% so the outermost ring has breathing room; never 0.
+            max: max > 0 ? max * 1.1 : 1,
+        };
+    });
+};
+exports.buildRadarIndicators = buildRadarIndicators;
+/**
+ * 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.
+ */
+var buildRadarSeriesData = function (series, indicatorCount) {
+    return series.map(function (s) {
+        var value = [];
+        for (var i = 0; i < indicatorCount; i++) {
+            value.push(toNumber(s.values[i]));
+        }
+        return { value: value, name: s.name };
+    });
+};
+exports.buildRadarSeriesData = buildRadarSeriesData;

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

package/dist/cjs/utils/region-map-loader.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__resetRegionMapLoaderForTests = exports.loadRegionMapGeo = exports.registerChartGeoMap = void 0;
+var tslib_1 = require("tslib");
+/**
+ * Lazy loader + registry for region-map (choropleth) geo data.
+ *
+ * echarts ships no map geometry, and the world GeoJSON plus the map
+ * chart module are dead weight for every non-map chart — so nothing
+ * here is imported eagerly. The renderer calls `loadRegionMapGeo(scope)`
+ * the first time a region-map spec is actually about to render:
+ *
+ *   - the echarts `MapChart` / `GeoComponent` / `VisualMapComponent`
+ *     modules are dynamically imported and registered once
+ *   - the default `"world"` scope is built by dynamically importing the
+ *     `world-atlas` countries TopoJSON (~110 KB) and converting it with
+ *     `topojson-client`
+ *   - any other scope must have been provided by the host through
+ *     `registerChartGeoMap(name, geoJson)` (e.g. a US-states GeoJSON)
+ *
+ * Failures latch (mirroring `echarts-gl-loader.ts`): a failed import
+ * warns once and keeps resolving null, so the renderer draws an empty
+ * chart instead of crashing or re-fetching on every update. Everything
+ * is SSR-safe — no window/document access.
+ */
+var echarts = tslib_1.__importStar(require("echarts/core"));
+var region_map_1 = require("./region-map");
+var registeredMaps = new Map();
+var modulesPromise = null;
+var worldPromise = null;
+var warnedScopes = new Set();
+var extractRegionNames = function (geoJson) {
+    var e_1, _a;
+    var _b;
+    var features = geoJson === null || geoJson === void 0 ? void 0 : geoJson.features;
+    if (!Array.isArray(features))
+        return [];
+    var names = [];
+    try {
+        for (var features_1 = tslib_1.__values(features), features_1_1 = features_1.next(); !features_1_1.done; features_1_1 = features_1.next()) {
+            var feature = features_1_1.value;
+            var name_1 = (_b = feature === null || feature === void 0 ? void 0 : feature.properties) === null || _b === void 0 ? void 0 : _b.name;
+            if (typeof name_1 === "string" && name_1.length > 0) {
+                names.push(name_1);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (features_1_1 && !features_1_1.done && (_a = features_1.return)) _a.call(features_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return names;
+};
+var warnOnce = function (scope, message) {
+    if (warnedScopes.has(scope))
+        return;
+    warnedScopes.add(scope);
+    // eslint-disable-next-line no-console
+    console.warn(message);
+};
+/**
+ * Register the echarts modules the choropleth needs (map series, geo
+ * coordinate system, visualMap). Dynamically imported so non-map
+ * charts never pay for them; a failed import latches as unavailable.
+ */
+var ensureEchartsMapModules = function () {
+    if (!modulesPromise) {
+        modulesPromise = Promise.all([
+            Promise.resolve().then(function () { return tslib_1.__importStar(require("echarts/charts")); }),
+            Promise.resolve().then(function () { return tslib_1.__importStar(require("echarts/components")); }),
+        ])
+            .then(function (_a) {
+            var _b = tslib_1.__read(_a, 2), charts = _b[0], components = _b[1];
+            echarts.use([
+                charts.MapChart,
+                components.GeoComponent,
+                components.VisualMapComponent,
+            ]);
+            return true;
+        })
+            .catch(function () { return false; });
+    }
+    return modulesPromise;
+};
+/**
+ * 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.
+ */
+var registerChartGeoMap = function (name, geoJson) {
+    registeredMaps.set(name, {
+        geoJson: geoJson,
+        regionNames: extractRegionNames(geoJson),
+        applied: false,
+    });
+};
+exports.registerChartGeoMap = registerChartGeoMap;
+var loadWorldGeoMap = function () {
+    if (!worldPromise) {
+        worldPromise = Promise.all([
+            Promise.resolve().then(function () { return tslib_1.__importStar(require("world-atlas/countries-110m.json")); }),
+            Promise.resolve().then(function () { return tslib_1.__importStar(require("topojson-client")); }),
+        ])
+            .then(function (_a) {
+            var _b;
+            var _c = tslib_1.__read(_a, 2), topologyModule = _c[0], topojson = _c[1];
+            var topology = (_b = topologyModule.default) !== null && _b !== void 0 ? _b : topologyModule;
+            var geoJson = topojson.feature(topology, topology.objects.countries);
+            var entry = {
+                geoJson: geoJson,
+                regionNames: extractRegionNames(geoJson),
+                applied: false,
+            };
+            registeredMaps.set(region_map_1.WORLD_GEO_SCOPE, entry);
+            return entry;
+        })
+            .catch(function () {
+            warnOnce(region_map_1.WORLD_GEO_SCOPE, "[charts] Failed to load the world map geometry for region-map charts; the chart will render empty.");
+            return null;
+        });
+    }
+    return worldPromise;
+};
+/**
+ * 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.
+ */
+var loadRegionMapGeo = function (scope) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var modulesReady, entry;
+    var _a;
+    return tslib_1.__generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, ensureEchartsMapModules()];
+            case 1:
+                modulesReady = _b.sent();
+                if (!modulesReady) {
+                    warnOnce("echarts-map-modules", "[charts] Failed to load the echarts map modules for region-map charts; the chart will render empty.");
+                    return [2 /*return*/, null];
+                }
+                entry = (_a = registeredMaps.get(scope)) !== null && _a !== void 0 ? _a : null;
+                if (!(!entry && scope === region_map_1.WORLD_GEO_SCOPE)) return [3 /*break*/, 3];
+                return [4 /*yield*/, loadWorldGeoMap()];
+            case 2:
+                entry = _b.sent();
+                _b.label = 3;
+            case 3:
+                if (!entry) {
+                    warnOnce(scope, "[charts] Region map: no geo data registered for scope \"".concat(scope, "\". Register one with registerChartGeoMap(\"").concat(scope, "\", geoJson)."));
+                    return [2 /*return*/, null];
+                }
+                if (!entry.applied) {
+                    echarts.registerMap(scope, entry.geoJson);
+                    entry.applied = true;
+                }
+                return [2 /*return*/, { regionNames: entry.regionNames }];
+        }
+    });
+}); };
+exports.loadRegionMapGeo = loadRegionMapGeo;
+/** Test hook — resets the module-level registries and latches. */
+var __resetRegionMapLoaderForTests = function () {
+    registeredMaps.clear();
+    modulesPromise = null;
+    worldPromise = null;
+    warnedScopes.clear();
+};
+exports.__resetRegionMapLoaderForTests = __resetRegionMapLoaderForTests;

package/dist/cjs/utils/region-map.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Region map / filled map (OOXML chartex `<cx:regionMap>`) helpers.
+ *
+ * Excel's filled map paints a choropleth: values keyed by geography
+ * (country/state names) shade regions on a map. The spec reuses the
+ * existing series/domain data model — the category domain carries the
+ * region labels and the first series carries the values — plus an
+ * optional `geoScope` naming the registered echarts map ("world" by
+ * default).
+ *
+ * Everything here is pure: region-name normalization + alias matching,
+ * choropleth data assembly, and the sequential color ramp for the value
+ * scale. The geo asset loading lives in `region-map-loader.ts`.
+ */
+type MaybeLike<T> = T | null | undefined;
+/** Default geo scope — the lazily loaded world map. */
+export declare const WORLD_GEO_SCOPE = "world";
+/**
+ * True when a basic-chart spec should render as a region-map
+ * choropleth: the first-class `"regionMap"` chart type, or any payload
+ * degraded to another `chartType` that preserves the authored class as
+ * `sourceChartType: "REGION_MAP"` (case-insensitive, mirroring
+ * `isParetoSpec` / `isOfPieChartSpec`).
+ */
+export declare const isRegionMapSpec: (spec: {
+    chartType?: string;
+    sourceChartType?: MaybeLike<string>;
+}) => boolean;
+/** Coerce a `geoScope` value to a usable map name (default "world"). */
+export declare const resolveGeoScope: (raw: MaybeLike<string>) => string;
+/**
+ * Normalize a region label for matching: trim, collapse whitespace,
+ * casefold, strip diacritics ("Côte d'Ivoire" → "cote d'ivoire"),
+ * unify curly apostrophes, and drop periods ("U.S." → "us").
+ */
+export declare const normalizeRegionKey: (name: MaybeLike<string>) => string;
+/**
+ * Groups of equivalent region names. Members are matched through
+ * `normalizeRegionKey`, so casing/diacritics/periods don't matter.
+ * Each group binds only when one of its members actually exists on the
+ * loaded map, so the table is map-agnostic: the canonical spellings
+ * below cover both the bundled world map's Natural Earth names
+ * ("United States of America", "Dem. Rep. Congo", …) and the long-form
+ * names hosts commonly author.
+ */
+export declare const REGION_NAME_ALIASES: readonly (readonly string[])[];
+/**
+ * Build a lookup from normalized label → the map's own region name.
+ * Exact (normalized) names always win; alias-group members resolve to
+ * whichever member exists on the map, and never shadow a real region
+ * name.
+ */
+export declare const buildRegionNameIndex: (regionNames: readonly string[]) => Map<string, string>;
+export type RegionMapDatum = {
+    /** The map's own region name (echarts matches `data[].name` on it). */
+    name: string;
+    value: number;
+};
+export type RegionMapData = {
+    /** Matched regions, deduped by region (last value wins). */
+    data: RegionMapDatum[];
+    /** Labels that matched no region on the map — skipped, never fatal. */
+    unmatched: string[];
+    /** visualMap extent derived from the matched values. */
+    min: number;
+    max: number;
+};
+/**
+ * Assemble echarts `map`-series data from parallel label/value arrays
+ * (category domain = region labels, first series = values).
+ *
+ * - labels are matched exactly first, then through the normalization +
+ *   alias layer; unmatched labels are collected (not thrown)
+ * - blank labels and non-finite values are skipped
+ * - duplicate labels collapse onto one region (last value wins)
+ * - min/max span the matched values; degenerate extents are widened so
+ *   the visualMap ramp stays valid (no data → 0..1, all-equal → the
+ *   value against 0, all-zero → 0..1)
+ */
+export declare const buildRegionMapData: (labels: readonly MaybeLike<string | number>[], values: readonly MaybeLike<string | number | boolean>[], regionNames: readonly string[]) => RegionMapData;
+/** Linear RGB mix of two 6-digit hex colors; `t` 0 → a, 1 → b. */
+export declare const mixHexColors: (a: string, b: string, t: number) => string;
+/**
+ * Sequential (single-hue, light→dark) color ramp for the choropleth's
+ * value scale, derived from the theme accent. Dark mode gets its own
+ * steps mixed toward the dark chart surface rather than a flipped
+ * light ramp, so low values stay legible on a dark background.
+ */
+export declare const buildSequentialColorRamp: (accentColor: MaybeLike<string>, isDarkMode: boolean) => string[];
+/**
+ * `console.warn` the unmatched region labels for a scope once — the
+ * chart re-renders on every data tick, so an unguarded warn would spam
+ * the console. Keyed by scope + label set; a different set of
+ * unmatched labels warns again.
+ */
+export declare const warnOnceForUnmatchedRegions: (scope: string, unmatched: readonly string[]) => void;
+/** Test hook — resets the warn-once registry. */
+export declare const __resetRegionMapWarningsForTests: () => void;
+export {};
+//# sourceMappingURL=region-map.d.ts.map

package/dist/cjs/utils/region-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"region-map.d.ts","sourceRoot":"","sources":["../../../utils/region-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;AAEzC,uDAAuD;AACvD,eAAO,MAAM,eAAe,UAAU,CAAC;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,MAAM;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CACrC,KAAG,OAGoD,CAAC;AAEzD,wEAAwE;AACxE,eAAO,MAAM,eAAe,GAAI,KAAK,SAAS,CAAC,MAAM,CAAC,KAAG,MAGxD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,SAAS,CAAC,MAAM,CAAC,KAAG,MAS3C,CAAC;AAEnB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAqDpD,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,aAAa,SAAS,MAAM,EAAE,KAC7B,GAAG,CAAC,MAAM,EAAE,MAAM,CA2BpB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,4DAA4D;IAC5D,IAAI,EAAE,cAAc,EAAE,CAAC;IACvB,uEAAuE;IACvE,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,wDAAwD;IACxD,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAOF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,SAAS,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAC7C,QAAQ,SAAS,SAAS,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,EAAE,EACvD,aAAa,SAAS,MAAM,EAAE,KAC7B,aAiCF,CAAC;AAeF,kEAAkE;AAClE,eAAO,MAAM,YAAY,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAU9D,CAAC;AAOF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACnC,aAAa,SAAS,CAAC,MAAM,CAAC,EAC9B,YAAY,OAAO,KAClB,MAAM,EAWR,CAAC;AAMF;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,GACtC,OAAO,MAAM,EACb,WAAW,SAAS,MAAM,EAAE,KAC3B,IAUF,CAAC;AAEF,iDAAiD;AACjD,eAAO,MAAM,gCAAgC,QAAO,IAEnD,CAAC"}