@epxing/utils 0.0.0-stage → 5.3.0-beta.1

package/dist/src/chart-data-adapters.js

@@ -0,0 +1,112 @@
+function excludeBoxplotMissingValues(params) {
+  var _a;
+  const fields = [...new Set((((_a = params.chartData) == null ? void 0 : _a.statisticalList) || []).map((item) => item.fieldCode).filter(Boolean))];
+  if (!fields.length) return;
+  const scopes = JSON.parse(params.scopeParams || "[]").map((item) => ({ ...item }));
+  if (scopes.length) {
+    scopes[0].lb = "(" + (scopes[0].lb || "");
+    const last = scopes[scopes.length - 1];
+    last.rb = (last.rb || "") + ")";
+    last.link = "and";
+  }
+  fields.forEach((field) => scopes.push({ field, mode: "not_null", link: "and" }));
+  scopes[scopes.length - 1].link = "";
+  params.scopeParams = JSON.stringify(scopes);
+}
+const numeric = (value) => {
+  if (value === void 0 || value === null || String(value).trim() === "") return null;
+  const number = typeof value === "number" ? value : Number(String(value ?? "").replace(/%$/, ""));
+  return Number.isFinite(number) && value !== null && value !== "" ? number : null;
+};
+const failure = (message) => ({ hasData: false, message });
+const quantile = (sorted, p) => {
+  const index = (sorted.length - 1) * p;
+  const lower = Math.floor(index);
+  return sorted[lower] + (sorted[Math.ceil(index)] - sorted[lower]) * (index - lower);
+};
+function summarizeBoxplot(values) {
+  const sorted = values.map(numeric).filter((value) => value !== null).sort((a, b) => a - b);
+  if (!sorted.length) return null;
+  const q1 = quantile(sorted, 0.25);
+  const median = quantile(sorted, 0.5);
+  const q3 = quantile(sorted, 0.75);
+  const gap = (q3 - q1) * 1.5;
+  const retained = sorted.filter((value) => value >= q1 - gap && value <= q3 + gap);
+  return { value: [retained[0], q1, median, q3, retained[retained.length - 1]], outliers: sorted.filter((value) => value < q1 - gap || value > q3 + gap), count: sorted.length };
+}
+function buildAdvancedChartOption(type, data, config = {}, chartData = {}, theme = "") {
+  var _a, _b, _c, _d;
+  const option = Object.fromEntries(Object.entries(config).filter(([key]) => key !== "title" && !key.startsWith("series-") && key !== "echartsOptionOverride"));
+  option.tooltip = { trigger: "item", confine: true, ...option.tooltip };
+  if ((_a = option.legend) == null ? void 0 : _a._orient) {
+    const { direction = "bottom", horizontal = "center", vertical = "center" } = option.legend._orient;
+    const across = direction === "top" || direction === "bottom";
+    option.legend = { ...option.legend, orient: across ? "horizontal" : "vertical", top: direction === "top" ? "20px" : !across && vertical === "top" ? "20px" : !across && vertical === "center" ? "center" : "auto", bottom: direction === "bottom" || !across && vertical === "bottom" ? "20px" : "auto", left: direction === "left" || across && horizontal === "left" ? "20px" : across && horizontal === "center" ? "center" : "auto", right: direction === "right" || across && horizontal === "right" ? "20px" : "auto" };
+    delete option.legend._orient;
+  }
+  if ((_b = option.dataZoom) == null ? void 0 : _b.show) {
+    option.dataZoom = [{ type: "slider", startValue: 0, ...option.dataZoom, endValue: Number(option.dataZoom.endValue || 5) - 1 }];
+  } else if (option.dataZoom && !Array.isArray(option.dataZoom)) delete option.dataZoom;
+  if (type === "boxplot") {
+    if (((_c = chartData.categoryList) == null ? void 0 : _c.length) || ((_d = chartData.statisticalList) == null ? void 0 : _d.length) !== 2) return failure("箱线图需要两个数字统计字段，并且不设置分类维度");
+    if (chartData.statisticalList.some((item) => item.type !== "indexField" || !item.fieldCode || item.fieldCode === "record")) return failure("箱线图请使用数字字段，不支持记录数或自定义统计项");
+    const rows = data == null ? void 0 : data.data;
+    if (!Array.isArray(rows) || !rows.length) return failure();
+    if (rows.some((row) => !Array.isArray(row) || row.length !== 2)) return failure("箱线图需要原始数字对数据");
+    const summaries = [0, 1].map((index) => summarizeBoxplot(rows.map((row) => row[index])));
+    if (summaries.some((item) => !item)) return failure();
+    const names = chartData.statisticalList.map((item, index) => item.name || `指标 ${index + 1}`);
+    option.grid = { containLabel: true, left: 30, right: 20, top: 30, bottom: 30, ...option.grid };
+    option.xAxis = { ...option.xAxis, type: "category", data: names };
+    option.yAxis = { type: "value", ...option.yAxis };
+    option.series = [{ type: "boxplot", name: "箱线", ...config["series-boxplot"], data: summaries.map((item, index) => ({ name: names[index], value: item.value })) }];
+    const outliers = summaries.flatMap((item, index) => item.outliers.map((value) => [index, value]));
+    option.series.push({ type: "scatter", name: "离群值", data: outliers });
+    return { hasData: true, option };
+  }
+  const series = data == null ? void 0 : data.series;
+  if (!Array.isArray(series) || !series.length || series.every((item) => {
+    var _a2;
+    return !((_a2 = item.data) == null ? void 0 : _a2.length);
+  })) return failure();
+  if (series.some((row) => !Array.isArray(row.data) || row.data.some((item) => numeric(item.value) === null))) return failure("当前统计结果包含非数值，不能生成此图表");
+  if (type === "gauge") {
+    const cells = series.flatMap((row) => row.data);
+    if (cells.length !== 1) return failure("仪表盘需要单个统计值；请设置一个指标且不拆分分类");
+    const cell = cells[0];
+    const value = numeric(cell.value);
+    option.series = [{ type: "gauge", min: Math.min(0, value), max: Math.max(100, value), progress: { show: true }, detail: { formatter: "{value}" }, ...config["series-gauge"], data: [{ ...cell, value }] }];
+    if (["dark", "technology"].includes(theme)) {
+      const gauge = option.series[0];
+      gauge.axisLabel = { color: "#d9e1ec", ...gauge.axisLabel };
+      gauge.detail = { color: "#d9e1ec", ...gauge.detail };
+      gauge.title = { color: "#d9e1ec", ...gauge.title };
+    }
+    if (!(Number(option.series[0].max) > Number(option.series[0].min))) return failure("仪表盘最大刻度必须大于最小刻度");
+    delete option.xAxis;
+    delete option.yAxis;
+    delete option.grid;
+  } else if (type === "treemap") {
+    if (series.some((row) => row.data.some((item) => numeric(item.value) < 0))) return failure("矩形树图的统计值不能为负数");
+    option.series = [{ type: "treemap", roam: false, breadcrumb: { show: true }, ...config["series-treemap"], data: series.map((row, index) => ({ name: row.name || `指标 ${index + 1}`, children: row.data.map((cell) => ({ ...cell, value: numeric(cell.value) })) })) }];
+    delete option.xAxis;
+    delete option.yAxis;
+    delete option.grid;
+  } else if (type === "heatmap") {
+    const categories = series[0].data.map((item) => item.name || "");
+    if (series.some((row) => row.data.length !== categories.length || row.data.some((cell, index) => (cell.name || "") !== categories[index]))) return failure("热力图要求各指标使用同一组分类维度");
+    const cells = series.flatMap((row, rowIndex) => row.data.map((cell, colIndex) => ({ ...cell, value: [colIndex, rowIndex, numeric(cell.value)] })));
+    const values = cells.map((cell) => cell.value[2]);
+    option.grid = { containLabel: true, left: 30, right: 30, top: 30, bottom: 60, ...option.grid };
+    option.xAxis = { type: "category", splitArea: { show: true }, ...option.xAxis, data: categories };
+    option.yAxis = { type: "category", splitArea: { show: true }, ...option.yAxis, data: series.map((row, index) => row.name || `指标 ${index + 1}`) };
+    option.visualMap = { min: values.reduce((min, value) => Math.min(min, value), Infinity), max: values.reduce((max, value) => Math.max(max, value), 1), calculable: true, orient: "horizontal", left: "center", bottom: 0, ...option.visualMap };
+    option.series = [{ type: "heatmap", label: { show: false }, ...config["series-heatmap"], data: cells }];
+  } else return failure("不支持的图表类型");
+  return { hasData: true, option };
+}
+export {
+  buildAdvancedChartOption,
+  excludeBoxplotMissingValues,
+  summarizeBoxplot
+};

package/dist/src/chart-option-override.js

@@ -0,0 +1,128 @@
+import { getChartType } from "./chart-registry.js";
+const own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const unsafeKeys = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+const MAX_OVERRIDE_BYTES = 64 * 1024;
+function validateChartOptionOverride(override, baseOption = {}, chartType = "") {
+  const errors = [];
+  if (!object(override)) return [{ path: "$", message: "覆盖层必须是 JSON 对象" }];
+  let encoded;
+  try {
+    encoded = JSON.stringify(override);
+  } catch {
+    return [{ path: "$", message: "覆盖层必须是可序列化的 JSON 对象" }];
+  }
+  const size = new TextEncoder().encode(encoded).length;
+  if (size > MAX_OVERRIDE_BYTES) errors.push({ path: "$", message: "覆盖层不能超过 64 KB" });
+  const visit = (value, path, depth = 0) => {
+    if (depth > 64) {
+      errors.push({ path, message: "配置层级不能超过 64 层" });
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => visit(item, `${path}[${index}]`, depth + 1));
+      return;
+    }
+    if (!object(value)) return;
+    for (const [key, child] of Object.entries(value)) {
+      const childPath = path === "$" ? key : `${path}.${key}`;
+      if (unsafeKeys.has(key)) errors.push({ path: childPath, message: "不支持的属性名" });
+      if (key === "source" && (path === "dataset" || /^dataset\[\d+\]$/.test(path))) errors.push({ path: childPath, message: "数据源由平台维护" });
+      if (key === "data" && /^series\[\d+\]$/.test(path)) errors.push({ path: childPath, message: "系列数据由平台维护" });
+      visit(child, childPath, depth + 1);
+    }
+  };
+  visit(override, "$");
+  if (own(override, "series")) {
+    const baseSeries = Array.isArray(baseOption.series) ? baseOption.series : [baseOption.series].filter(Boolean);
+    if (!Array.isArray(override.series) || override.series.length !== baseSeries.length || !override.series.every(object)) {
+      errors.push({ path: "series", message: `系列覆盖必须与当前 ${baseSeries.length} 个系列逐项对应` });
+    } else {
+      override.series.forEach((series, index) => {
+        var _a, _b, _c;
+        if (own(series, "type") && series.type !== ((_a = baseSeries[index]) == null ? void 0 : _a.type)) errors.push({ path: `series[${index}].type`, message: "不能改变平台系列类型" });
+        if (own(series, "coordinateSystem")) {
+          const coordinate = ((_b = baseSeries[index]) == null ? void 0 : _b.coordinateSystem) || ((_c = getChartType(chartType)) == null ? void 0 : _c.coordinate);
+          if (series.coordinateSystem !== coordinate) errors.push({ path: `series[${index}].coordinateSystem`, message: "不能改变平台坐标系" });
+        }
+      });
+    }
+  }
+  if (Array.isArray(override.dataset)) errors.push({ path: "dataset", message: "暂不支持替换数据集数组" });
+  if (own(override, "dataset") && (!object(override.dataset) || Array.isArray(baseOption.dataset))) errors.push({ path: "dataset", message: "不能替换平台数据集结构" });
+  for (const axis of ["xAxis", "yAxis"]) {
+    if (own(override, axis) && !(object(override[axis]) || Array.isArray(override[axis]) && override[axis].length && override[axis].every(object))) {
+      errors.push({ path: axis, message: "坐标轴必须是对象或非空对象数组" });
+    }
+  }
+  if (getChartType(chartType) && getChartType(chartType).coordinate !== "cartesian2d") {
+    for (const axis of ["xAxis", "yAxis", "grid", "dataZoom"]) {
+      if (own(override, axis)) errors.push({ path: axis, message: "当前图表类型不使用直角坐标系" });
+    }
+  }
+  return errors;
+}
+function mergeObject(base, patch) {
+  const result = object(base) ? { ...base } : {};
+  for (const [key, value] of Object.entries(patch)) {
+    if (object(value)) result[key] = mergeObject(result[key], value);
+    else if (Array.isArray(value)) result[key] = value.map((item) => object(item) ? mergeObject({}, item) : item);
+    else result[key] = value;
+  }
+  return result;
+}
+function applyChartOptionOverride(baseOption, override, chartType = "") {
+  if (override === void 0) return baseOption;
+  const errors = validateChartOptionOverride(override, baseOption, chartType);
+  if (errors.length) return baseOption;
+  const { series, ...other } = override;
+  const result = mergeObject(baseOption, other);
+  for (const key of ["xAxis", "yAxis", "grid", "legend", "visualMap", "dataZoom"]) {
+    if (Array.isArray(other[key])) {
+      const base = Array.isArray(baseOption[key]) ? baseOption[key] : [baseOption[key]].filter(Boolean);
+      result[key] = Array.from({ length: Math.max(base.length, other[key].length) }, (_, index) => mergeObject(base[index], other[key][index] || {}));
+    } else if (object(other[key]) && Array.isArray(baseOption[key])) {
+      result[key] = baseOption[key].map((item, index) => index === 0 ? mergeObject(item, other[key]) : item);
+    }
+  }
+  if (series) {
+    result.series = baseOption.series.map((item, index) => mergeObject(item, series[index]));
+  }
+  return result;
+}
+function setChartOption(host, baseOption, override) {
+  var _a;
+  host.chartOption = applyChartOptionOverride(baseOption, override, host.chartType);
+  if (host.designMode && ((_a = host.$refs) == null ? void 0 : _a.container)) {
+    host.$refs.container.dispatchEvent(new CustomEvent("epx-chart-option-built", {
+      bubbles: true,
+      detail: { base: baseOption, effective: host.chartOption }
+    }));
+  }
+}
+function validateChartOptionRendering(option, echarts) {
+  var _a;
+  if (!echarts) return [{ path: "$", message: "等待图表加载后再预览" }];
+  const element = document.createElement("div");
+  element.style.cssText = "position:fixed;left:-10000px;top:0;width:800px;height:400px;visibility:hidden;pointer-events:none";
+  document.body.appendChild(element);
+  let chart;
+  try {
+    chart = echarts.init(element);
+    chart.setOption(option, { notMerge: true });
+    const expected = Array.isArray(option.series) ? option.series.length : option.series ? 1 : 0;
+    if (chart.getOption && (((_a = chart.getOption().series) == null ? void 0 : _a.length) || 0) !== expected) throw new Error("当前 ECharts 未能加载全部系列类型");
+    return [];
+  } catch (error) {
+    return [{ path: "$", message: `图表预览失败：${error.message}` }];
+  } finally {
+    if (chart) chart.dispose();
+    element.remove();
+  }
+}
+export {
+  applyChartOptionOverride,
+  setChartOption,
+  validateChartOptionOverride,
+  validateChartOptionRendering
+};

package/dist/src/chart-option-paths.js

@@ -0,0 +1,64 @@
+function chartOverridePaths(key, base = {}, patch = {}) {
+  if (key === "title" || key.startsWith("title.")) return [];
+  if (key.startsWith("series-")) {
+    const [group, ...parts2] = key.split(".");
+    const type = group.slice(7) === "wordcloud" ? "wordCloud" : group.slice(7);
+    if (["total", "totalText"].includes(parts2[0])) return [];
+    const native = parts2[0] === "showArea" ? ["areaStyle"] : parts2[0] === "barType" ? ["stack"] : parts2.join(".") === "label.customFormatter" ? ["label", "formatter"] : parts2;
+    return (base.series || []).flatMap((series, index) => series.type === type ? [["series", index, ...native]] : []);
+  }
+  if (/^yAxis\.(leftAxis|rightAxis)\./.test(key)) {
+    const [, side, ...parts2] = key.split(".");
+    return [["yAxis", side === "leftAxis" ? 0 : 1, ...parts2]];
+  }
+  if (["yAxis.leftName", "yAxis.rightName"].includes(key)) return [["yAxis", key === "yAxis.leftName" ? 0 : 1, "name"]];
+  if (key.startsWith("legend._orient.")) {
+    const fields = key.endsWith(".horizontal") ? ["left", "right"] : key.endsWith(".vertical") ? ["top", "bottom"] : ["orient", "left", "right", "top", "bottom"];
+    return fields.map((field) => ["legend", field]);
+  }
+  const [root, ...parts] = key.split(".");
+  if (Array.isArray(patch[root])) return patch[root].map((_, index) => [root, index, ...parts]);
+  return [[root, ...parts]];
+}
+const readPath = (value, path) => {
+  if (!path.length) return value;
+  if (Array.isArray(value) && typeof path[0] !== "number") return value.map((item) => readPath(item, path)).find((item) => item !== void 0);
+  if (!Array.isArray(value) && typeof path[0] === "number") return path[0] === 0 ? readPath(value, path.slice(1)) : void 0;
+  return readPath(value == null ? void 0 : value[path[0]], path.slice(1));
+};
+function isChartPathOverridden(patch, key, base) {
+  return chartOverridePaths(key, base, patch).some((path) => readPath(patch, path) !== void 0);
+}
+function clearChartOverridePath(patch, key, base) {
+  const remove = (value, path) => {
+    if (!value || !path.length) return;
+    if (Array.isArray(value) && typeof path[0] !== "number") {
+      value.forEach((item) => remove(item, path));
+      return;
+    }
+    if (!Array.isArray(value) && typeof path[0] === "number") {
+      if (path[0] === 0) remove(value, path.slice(1));
+      return;
+    }
+    const [part, ...rest] = path;
+    if (!rest.length) {
+      if (Array.isArray(value)) value[part] = {};
+      else delete value[part];
+    } else {
+      remove(value[part], rest);
+      if (value[part] && !Array.isArray(value[part]) && typeof value[part] === "object" && !Object.keys(value[part]).length && !Array.isArray(value)) delete value[part];
+    }
+  };
+  const paths = chartOverridePaths(key, base, patch);
+  for (const path of paths) remove(patch, path);
+  for (const root of new Set(paths.map((path) => path[0]))) {
+    const value = patch[root];
+    if (Array.isArray(value) && value.every((item) => item && typeof item === "object" && !Object.keys(item).length)) delete patch[root];
+  }
+  return patch;
+}
+export {
+  chartOverridePaths,
+  clearChartOverridePath,
+  isChartPathOverridden
+};

package/dist/src/chart-registry.js

@@ -0,0 +1,46 @@
+const chartTypes = [
+  { type: "table", text: "统计表", icon: "epx-icon-tongjibiao", component: "chart-table", requestType: "table", coordinate: "none" },
+  { type: "pie", text: "饼状图", icon: "epx-icon-bingzhuangtu", component: "chart-common", requestType: "pie", coordinate: "none" },
+  { type: "circularPie", text: "环形饼图", icon: "epx-icon-bingzhuangtu", component: "chart-common", requestType: "pie", coordinate: "none" },
+  { type: "line", text: "折线图", icon: "epx-icon-zhexiantu", component: "chart-common", requestType: "line", coordinate: "cartesian2d" },
+  { type: "column", text: "柱状图", icon: "epx-icon-zhuzhuangtu", component: "chart-common", requestType: "bar", coordinate: "cartesian2d" },
+  { type: "horiColumn", text: "横向柱图", icon: "epx-icon-zhuzhuangtu", component: "chart-common", requestType: "bar", cellScopeType: "column", coordinate: "cartesian2d" },
+  { type: "funnel", text: "漏斗图", icon: "epx-icon-loudoutu", component: "chart-common", requestType: "funnel", coordinate: "none" },
+  { type: "wordcloud", text: "词云", icon: "epx-icon-ciyun", component: "chart-wordcloud", requestType: "wordCloud", coordinate: "none" },
+  { type: "radar", text: "雷达图", icon: "epx-icon-leidatu", component: "chart-radar", requestType: "radar", coordinate: "radar" },
+  { type: "columnAndLine", text: "折柱混合", icon: "epx-icon-zhezhutu", component: "chart-common", requestType: "bar", coordinate: "cartesian2d" },
+  { type: "scatter", text: "散点图", icon: "epx-icon-sandiantu", component: "chart-scatter", requestType: "scatter", coordinate: "cartesian2d", binding: "numericPairs", drill: false },
+  { type: "map", text: "地图", icon: "epx-icon-ditu", component: "chart-map", requestType: "map", coordinate: "geo" },
+  { type: "gauge", text: "仪表盘", icon: "epx-icon-leidatu", component: "chart-advanced", requestType: "bar", cellScopeType: "column", coordinate: "none", dataHint: "单个统计值；设置一个指标且不拆分分类。" },
+  { type: "treemap", text: "矩形树图", icon: "epx-icon-tongjibiao", component: "chart-advanced", requestType: "bar", cellScopeType: "column", coordinate: "none", dataHint: "按指标、分类组成两层矩形树，使用非负统计值；叶子支持钻取。" },
+  { type: "heatmap", text: "热力图", icon: "epx-icon-zhuzhuangtu", component: "chart-advanced", requestType: "bar", cellScopeType: "column", coordinate: "cartesian2d", dataHint: "横轴为分类，纵轴为指标；各指标使用同一组分类。" },
+  { type: "boxplot", text: "箱线图", selectable: false, icon: "epx-icon-zhexiantu", component: "chart-advanced", requestType: "scatter", coordinate: "cartesian2d", binding: "numericPairs", drill: false, dataHint: "选择两个数字统计字段，不设置分类；使用原始值计算四分位数与 1.5 倍四分位距的离群值，不支持钻取。" }
+];
+const selectableChartTypes = chartTypes.filter((item) => item.selectable !== false);
+function getChartType(type) {
+  return chartTypes.find((item) => item.type === (type === "bar" ? "column" : type));
+}
+const chartConfigCategories = [
+  { key: "all", label: "全部" },
+  { key: "appearance", label: "外观" },
+  { key: "axis", label: "坐标与刻度" },
+  { key: "shape", label: "图形" },
+  { key: "label", label: "标签与提示" },
+  { key: "interaction", label: "交互" },
+  { key: "advanced", label: "高级" }
+];
+function getChartConfigCategory(key) {
+  if (["title", "grid", "color", "backgroundColor"].includes(key)) return "appearance";
+  if (["xAxis", "yAxis", "dualAxes", "dataZoom"].includes(key)) return "axis";
+  if (key.startsWith("series-") || ["series.map", "radar", "scatter", "table", "visualMap"].includes(key)) return "shape";
+  if (["legend", "tooltip"].includes(key)) return "label";
+  if (key === "toolbox") return "interaction";
+  return "advanced";
+}
+export {
+  chartConfigCategories,
+  chartTypes,
+  getChartConfigCategory,
+  getChartType,
+  selectableChartTypes
+};

package/dist/src/chart-render-host.js

@@ -0,0 +1,57 @@
+import { getChartType } from "./chart-registry.js";
+const registeredThemes = /* @__PURE__ */ new WeakSet();
+function registerChartThemes(echarts, themes) {
+  if (registeredThemes.has(echarts)) return;
+  for (const key in themes) echarts.registerTheme(key, themes[key]);
+  registeredThemes.add(echarts);
+}
+function disposeChartHost(host) {
+  var _a;
+  if (host.observedChartDom) {
+    (_a = host.resizeObserver) == null ? void 0 : _a.unobserve(host.observedChartDom);
+    host.observedChartDom = null;
+  }
+  if (!host.myChart) return;
+  host.myChart.off("click", host.openPivotPage);
+  host.myChart.dispose();
+  host.myChart = null;
+  host.renderedChartTheme = null;
+}
+function renderChartHost(host, option, settings) {
+  var _a, _b, _c, _d, _e;
+  const element = (_a = host.$refs) == null ? void 0 : _a.chart;
+  if (!element || !host.echarts || !option) return false;
+  const { width, height } = element.getBoundingClientRect();
+  if (width <= 0 || height <= 0) return false;
+  const staleDom = host.myChart && host.myChart.getDom && host.myChart.getDom() !== element;
+  const theme = settings && Object.prototype.hasOwnProperty.call(settings, "theme") ? settings.theme : host.chartTheme;
+  const changedTheme = host.myChart && host.renderedChartTheme !== theme;
+  if (staleDom || changedTheme) disposeChartHost(host);
+  if (!host.myChart) {
+    host.myChart = host.echarts.init(element, theme);
+    host.renderedChartTheme = theme;
+    if (host.openClickEvent) host.myChart.on("click", host.openPivotPage);
+  }
+  if (host.resizeObserver && host.observedChartDom !== element) {
+    if (host.observedChartDom) host.resizeObserver.unobserve(host.observedChartDom);
+    host.resizeObserver.observe(element);
+    host.observedChartDom = element;
+  }
+  try {
+    host.myChart.setOption(option, { notMerge: true });
+    const expected = Array.isArray(option.series) ? option.series.length : option.series ? 1 : 0;
+    const enforceSeries = ((_b = getChartType(host.chartType)) == null ? void 0 : _b.component) === "chart-advanced" || ((_d = (_c = host.chartConfigs) == null ? void 0 : _c.chartConfig) == null ? void 0 : _d.echartsOptionOverride) !== void 0;
+    if (enforceSeries && host.myChart.getOption && (((_e = host.myChart.getOption().series) == null ? void 0 : _e.length) || 0) !== expected) throw new Error("未能加载全部系列类型");
+  } catch (error) {
+    disposeChartHost(host);
+    host.error = true;
+    host.chartErrorText = `图表配置无法渲染：${error.message}`;
+    return false;
+  }
+  return true;
+}
+export {
+  disposeChartHost,
+  registerChartThemes,
+  renderChartHost
+};

package/dist/src/chart-request-broker.js

@@ -0,0 +1,176 @@
+const stable = (value) => {
+  if (Array.isArray(value)) return value.map(stable);
+  if (value && typeof value === "object") return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable(value[key])]));
+  return value;
+};
+const encode = (value) => JSON.stringify(stable(value));
+function createChartRequestBroker({ concurrency = 6, ttl = 3e4, maxEntries = 64, maxBytes = 2 * 1024 * 1024, now = Date.now } = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  const jobs = /* @__PURE__ */ new Set();
+  const inFlight = /* @__PURE__ */ new Map();
+  const queue = [];
+  const counters = { hits: 0, misses: 0, coalesced: 0, cancelled: 0, peakActive: 0 };
+  let active = 0;
+  let bytes = 0;
+  let context = null;
+  let expiryTimer = null;
+  let disposed = false;
+  const remove = (key) => {
+    const entry = cache.get(key);
+    if (entry) bytes -= entry.bytes;
+    cache.delete(key);
+  };
+  const expire = () => {
+    if (expiryTimer) clearTimeout(expiryTimer);
+    expiryTimer = null;
+    for (const [key, entry] of cache) if (entry.expires <= now()) remove(key);
+    if (cache.size) {
+      const next = Math.min(...Array.from(cache.values(), (entry) => entry.expires));
+      expiryTimer = setTimeout(expire, Math.max(1, next - now()));
+    }
+  };
+  const clear = () => {
+    cache.clear();
+    bytes = 0;
+    if (expiryTimer) clearTimeout(expiryTimer);
+    expiryTimer = null;
+  };
+  const forget = (job) => {
+    jobs.delete(job);
+    if (inFlight.get(job.key) === job) inFlight.delete(job.key);
+  };
+  const cancel = (job) => {
+    var _a;
+    if (job.cancelled) return;
+    job.cancelled = true;
+    job.invalidated = true;
+    for (const consumer of job.consumers) consumer.resolve(null);
+    job.consumers.clear();
+    (_a = job.controller) == null ? void 0 : _a.abort();
+    const index = queue.indexOf(job);
+    if (index !== -1) queue.splice(index, 1);
+    if (!job.started) forget(job);
+    counters.cancelled++;
+  };
+  const syncContext = (current) => {
+    if (context && context.principal !== current.principal) {
+      clear();
+      for (const job of [...jobs]) cancel(job);
+    } else if (context && context.credential !== current.credential) {
+      clear();
+    }
+    context = current;
+  };
+  const invalidate = (reportId) => {
+    for (const [key, entry] of cache) if (!reportId || entry.reportId === reportId) remove(key);
+    for (const job of jobs) if (!reportId || job.reportId === reportId) job.invalidated = true;
+    expire();
+  };
+  const pump = () => {
+    if (disposed) return;
+    while (active < concurrency && queue.length) {
+      const job = queue.shift();
+      syncContext(job.getContext());
+      if (job.cancelled || !job.consumers.size) {
+        forget(job);
+        continue;
+      }
+      job.started = true;
+      job.credential = context.credential;
+      job.version = job.getVersion();
+      job.cacheKey = encode([job.componentId, job.params, job.version]);
+      job.controller = new AbortController();
+      active++;
+      counters.peakActive = Math.max(counters.peakActive, active);
+      Promise.resolve().then(() => job.execute(job.controller.signal)).then((data) => {
+        if (disposed || job.cancelled) return;
+        const current = job.getContext();
+        syncContext(current);
+        if (job.cancelled) return;
+        job.settled = true;
+        const encoded = JSON.stringify(data);
+        const size = encoded ? (encoded.length + job.cacheKey.length) * 2 : 0;
+        if (job.cacheable && !job.invalidated && current.credential === job.credential && job.getVersion() === job.version && encoded && size <= maxBytes / 2) {
+          remove(job.cacheKey);
+          cache.set(job.cacheKey, { encoded, bytes: size, expires: now() + ttl, reportId: job.reportId });
+          bytes += size;
+          for (const cachedKey of cache.keys()) {
+            if (cache.size <= maxEntries && bytes <= maxBytes) break;
+            remove(cachedKey);
+          }
+          expire();
+        }
+        for (const consumer of job.consumers) consumer.resolve(encoded === void 0 ? data : JSON.parse(encoded));
+      }).catch((error) => {
+        job.settled = true;
+        if (!job.cancelled && !disposed) for (const consumer of job.consumers) consumer.reject(error);
+      }).finally(() => {
+        job.consumers.clear();
+        forget(job);
+        active--;
+        pump();
+      });
+    }
+  };
+  return {
+    request({ params, componentId = params.reportId, execute, getContext, getVersion = () => "", cacheable = false, force = false }) {
+      if (disposed) return { promise: Promise.resolve(null), cancel: () => {
+      } };
+      const current = getContext();
+      syncContext(current);
+      expire();
+      const version = getVersion();
+      const key = encode([componentId, params, version]);
+      const reportId = params.reportId;
+      if (force) invalidate(reportId);
+      const entry = cache.get(key);
+      if (cacheable && current.credential && !force && entry) {
+        counters.hits++;
+        cache.delete(key);
+        cache.set(key, entry);
+        return {
+          promise: Promise.resolve().then(() => {
+            const latest = getContext();
+            return latest.principal === current.principal && latest.credential === current.credential ? JSON.parse(entry.encoded) : null;
+          }),
+          cancel: () => {
+          }
+        };
+      }
+      let job = !force && inFlight.get(key);
+      if (job && !job.settled && !job.cancelled && !job.invalidated && job.credential === current.credential) counters.coalesced++;
+      else {
+        counters.misses++;
+        job = { key, componentId, params, reportId, execute, getContext, getVersion, version, credential: current.credential, cacheable: cacheable && !!current.credential, consumers: /* @__PURE__ */ new Set() };
+        jobs.add(job);
+        inFlight.set(key, job);
+        queue.push(job);
+      }
+      const consumer = {};
+      const promise = new Promise((resolve, reject) => Object.assign(consumer, { resolve, reject }));
+      job.consumers.add(consumer);
+      pump();
+      return {
+        promise,
+        cancel: () => {
+          if (!job.consumers.delete(consumer)) return;
+          consumer.resolve(null);
+          if (!job.consumers.size) cancel(job);
+        }
+      };
+    },
+    invalidate,
+    stats() {
+      return { ...counters, active, queued: queue.length, entries: cache.size, bytes, disposed };
+    },
+    dispose() {
+      disposed = true;
+      clear();
+      for (const job of [...jobs]) cancel(job);
+      context = null;
+    }
+  };
+}
+export {
+  createChartRequestBroker
+};