@opentinyvue/vue-renderless 3.21.0

package/chart-map/index.js

@@ -0,0 +1,118 @@
+import {
+  __spreadValues
+} from "../chunk-G2ADBYYC.js";
+import { getFormated, getMapJSON, getLegend as getLegendMap } from "../chart-core/deps/utils";
+import { itemPoint, itemLabel, itemContent } from "../chart-core/deps/constants";
+import { isNull } from "../common/type";
+const getTooltip = ({ dataType, digit, dataStore, metrics, color, labelMap }) => {
+  function formatter(item) {
+    let tplt = [];
+    if (!item.name) {
+      return "";
+    }
+    tplt.push(`${itemLabel(item.name)}<br>`);
+    metrics.forEach((label, index) => {
+      let title = isNull(labelMap[label]) ? label : labelMap[label];
+      tplt.push(`${itemPoint(color[index])}${itemLabel(title)}`);
+      if (dataStore[item.name]) {
+        tplt.push(itemContent(getFormated(dataStore[item.name][label], dataType[label], digit)));
+      } else {
+        tplt.push(itemContent("-"));
+      }
+      tplt.push("<br>");
+    });
+    return tplt.join("");
+  }
+  return { formatter };
+};
+const setGeoLabel = (value, target, label) => {
+  if (typeof value === "object") {
+    target[label] = value;
+  } else if (value) {
+    target[label] = { show: true };
+  }
+};
+const getSeries = (args) => {
+  let { position, selectData, dimension, metrics, rows, label, selectedMode, roam, center, aspectScale, zoom } = args;
+  const { boundingCoords, labelMap, scaleLimit, mapGrid, itemStyle = { areaColor: "rgba(25,25,25,0.05)" } } = args;
+  const { result = [], mapBase = { type: "map", map: position } } = {};
+  const { emphasis = { itemStyle: { areaColor: "rgba(25,25,25,0.2)" }, label: { color: "#191919" } } } = {};
+  metrics.forEach((itemName) => {
+    const name = !isNull(labelMap[itemName]) ? labelMap[itemName] : itemName;
+    const data = [];
+    const itemResult = __spreadValues({
+      name,
+      data,
+      selectedMode,
+      roam,
+      center,
+      aspectScale,
+      boundingCoords,
+      zoom,
+      scaleLimit
+    }, mapBase);
+    if (mapGrid) {
+      Object.keys(mapGrid).forEach((key) => itemResult[key] = mapGrid[key]);
+    }
+    setGeoLabel(itemStyle, itemResult, "itemStyle");
+    setGeoLabel(label, itemResult, "label");
+    rows.forEach((row) => itemResult.data.push({ name: row[dimension], value: row[itemName], selected: selectData }));
+    itemResult.emphasis = emphasis;
+    itemResult.label = __spreadValues({ color: "#191919" }, itemResult.label);
+    result.push(itemResult);
+  });
+  return result;
+};
+const registerMap = (args, mapOrigin, echarts) => {
+  const { _once, registerSign, beforeRegisterMap, beforeRegisterMapOnce } = args;
+  const { registerSignOnce, position, specialAreas } = args;
+  if (!_once[registerSign] && beforeRegisterMap) {
+    mapOrigin = beforeRegisterMap(mapOrigin);
+  }
+  if (!_once[registerSign] && beforeRegisterMapOnce && !_once[registerSignOnce]) {
+    _once[registerSignOnce] = true;
+    mapOrigin = beforeRegisterMapOnce(mapOrigin);
+  }
+  if (!_once[registerSign]) {
+    _once[registerSign] = true;
+    echarts.registerMap(position, mapOrigin, specialAreas);
+  }
+};
+const map = (columns, rows, settings, extra) => {
+  const { position = "", selectData = false, selectedMode, label = true, dataType = {}, digit = 2 } = settings;
+  const { dimension = columns[0], roam, center, aspectScale, boundingCoords, zoom } = settings;
+  const { scaleLimit, legendName = {}, labelMap = {}, mapGrid, itemStyle, positionJsonLink, emphasis } = settings;
+  const { beforeRegisterMap, beforeRegisterMapOnce, mapURLProfix = extra.baseUrl || "", specialAreas = {} } = settings;
+  const { mapOrigin } = settings;
+  let metrics = columns.slice(0);
+  if (!settings.metrics) {
+    metrics.splice(columns.indexOf(dimension), 1);
+  } else {
+    metrics = settings.metrics;
+  }
+  const { tooltipVisible, legendVisible, color, _once, echartsLib: echarts } = extra;
+  const dataStore = {};
+  rows.forEach((row) => dataStore[row[dimension]] = row);
+  const tooltip = tooltipVisible && getTooltip({ dataType, digit, dataStore, metrics, color, labelMap });
+  const legend = legendVisible && getLegendMap({ metrics, legendName, labelMap });
+  const seriesParams = { position, selectData, label, itemStyle, dimension, metrics, rows, selectedMode, roam };
+  Object.assign(seriesParams, { center, aspectScale, boundingCoords, zoom, labelMap, scaleLimit, mapGrid, emphasis });
+  const series = getSeries(seriesParams);
+  const registerSign = `MAP_REGISTER_${position}`;
+  const registerSignOnce = `ONCE_MAP_REGISTER_${position}`;
+  const registerOptions = { _once, beforeRegisterMap, beforeRegisterMapOnce, position };
+  Object.assign(registerOptions, { specialAreas, registerSign, registerSignOnce });
+  if (mapOrigin) {
+    registerMap(registerOptions, mapOrigin, echarts);
+    return { series, tooltip, legend };
+  } else {
+    const param = { position, positionJsonLink, beforeRegisterMapOnce, mapURLProfix };
+    return getMapJSON(param).then((json) => {
+      registerMap(registerOptions, json, echarts);
+      return { series, tooltip, legend };
+    });
+  }
+};
+export {
+  map
+};

package/chart-pie/index.js

@@ -0,0 +1,146 @@
+import {
+  __spreadValues
+} from "../chunk-G2ADBYYC.js";
+import { getFormated, setArrayValue, cloneDeep } from "../chart-core/deps/utils";
+import { itemPoint, itemLabel, itemContent } from "../chart-core/deps/constants";
+import { isNull } from "../common/type";
+const pieRadius = 100;
+const ringRadius = [90, 100];
+const roseRingRadius = [20, 100];
+const pieOffsetY = "50%";
+const modifySeries = ({ series, limitShowNum, t }) => {
+  let firstSerie = series[0];
+  if (limitShowNum && limitShowNum < firstSerie.data.length) {
+    let firstSerieData = firstSerie.data;
+    let remainArr = firstSerieData.slice(limitShowNum, firstSerieData.length);
+    let sum = 0;
+    remainArr.forEach((item) => sum += item.value);
+    firstSerie.data = firstSerieData.slice(0, limitShowNum);
+    firstSerie.data.push({ name: t("ui.chart.other"), value: sum });
+  }
+};
+const getPieSeries = (args) => {
+  const { dataType, digit, dimension, emphasis, innerRows, isRing, itemStyle, label, labelLine } = args;
+  const { level, limitShowNum, metrics, offsetY, percentShow, radius, roseType, selectedMode, t } = args;
+  let { series = [], levelTemp = {}, rowsTemp = [] } = {};
+  if (!level) {
+    rowsTemp.push(innerRows);
+  } else {
+    level.forEach((levelItems, index) => levelItems.forEach((item) => setArrayValue(levelTemp, item, index)));
+    innerRows.forEach((row) => {
+      let itemLevel = levelTemp[row[dimension]];
+      if (itemLevel && itemLevel.length) {
+        itemLevel.forEach((levelItem) => setArrayValue(rowsTemp, levelItem, row));
+      }
+    });
+  }
+  let serieBase = { type: "pie", selectedMode, emphasis, roseType, center: ["50%", offsetY] };
+  let rowsCount = rowsTemp.length;
+  let centerWidth = radius / rowsCount;
+  rowsTemp.forEach((dataRows, index) => {
+    let serie = __spreadValues({ data: [] }, serieBase);
+    if (!index) {
+      serie.radius = isRing ? radius : centerWidth;
+    } else {
+      let outerWidth = centerWidth + radius / (2 * rowsCount) * (2 * index - 1);
+      let innerWidth = outerWidth + radius / (2 * rowsCount);
+      serie.radius = [outerWidth, innerWidth];
+    }
+    rowsCount > 1 && index === 0 && (serie.label = { position: "inner" });
+    serie.label = __spreadValues({ color: "#191919" }, label);
+    serie.labelLine = __spreadValues({ smooth: true, lineStyle: { color: "#bbb" } }, labelLine);
+    serie.itemStyle = __spreadValues({ borderWidth: 2, borderColor: "#fff" }, itemStyle);
+    if (percentShow) {
+      let position = rowsCount > 1 && index === 0 ? "inner" : "outside";
+      let formatter = function(item) {
+        let tplt = [];
+        tplt.push(`${item.name}:`);
+        tplt.push(getFormated(item.value, dataType, digit));
+        tplt.push(`(${item.percent}%)`);
+        return tplt.join("");
+      };
+      serie.label = { normal: { show: true, position, formatter } };
+    }
+    serie.data = dataRows.map((row) => ({ name: row[dimension], value: row[metrics] }));
+    series.push(serie);
+  });
+  modifySeries({ series, limitShowNum, t });
+  return series;
+};
+const getPieLegend = (args) => {
+  const { dimension, innerRows, legendLimit, legendName, level, limitShowNum, t } = args;
+  let { legend = [], levelTemp = [] } = {};
+  if (level) {
+    level.forEach((levelItem) => levelItem.forEach((item) => levelTemp.push(item)));
+    legend = levelTemp;
+  } else if (limitShowNum && limitShowNum < innerRows.length) {
+    for (let i = limitShowNum - 1; i >= 0; i--) {
+      legend.unshift(innerRows[i][dimension]);
+    }
+    legend.push(t("ui.chart.other"));
+  } else {
+    legend = innerRows.map((row) => row[dimension]);
+  }
+  if (legend.length) {
+    let show = legend.length < legendLimit;
+    let formatter = function(name) {
+      return !isNull(legendName[name]) ? legendName[name] : name;
+    };
+    return { data: legend, show, formatter };
+  } else {
+    return false;
+  }
+};
+const getPieTooltip = (args) => {
+  const { dataType, digit, dimension, innerRows, limitShowNum, metrics, t } = args;
+  let { localeOther = t("ui.chart.other"), remainArr, sum = 0 } = {};
+  let mapHandler = (row) => {
+    sum += row[metrics];
+    return { name: row[dimension], value: row[metrics] };
+  };
+  remainArr = innerRows.map(mapHandler).slice(limitShowNum, innerRows.length);
+  let formatter = function(item) {
+    let tplt = [itemPoint(item.color)];
+    let percent;
+    if (!limitShowNum || item.name !== localeOther) {
+      tplt.push(itemLabel(item.name));
+      tplt.push(itemContent(getFormated(item.value, dataType, digit)));
+      tplt.push(itemContent(`(${item.percent}%)`));
+    } else {
+      tplt.push(localeOther + ":");
+      remainArr.forEach(({ name, value }) => {
+        percent = getFormated(value / sum, "percent");
+        tplt.push(`<br>${itemLabel(name)}`);
+        tplt.push(itemContent(getFormated(value, dataType, digit)));
+        tplt.push(itemContent(percent));
+      });
+    }
+    return tplt.join("");
+  };
+  return { formatter };
+};
+const pie = (columns, rows, settings, extra, isRing) => {
+  const innerRows = cloneDeep(rows);
+  const { dataType = "normal", digit = 2, dimension = columns[0], emphasis = { scale: true } } = settings;
+  const { itemStyle, label = false, labelLine, legendLimit = 30, legendName = {}, level = false } = settings;
+  const { limitShowNum = 0, metrics = columns[1], offsetY = pieOffsetY, percentShow } = settings;
+  const { roseType = false, selectedMode = false } = settings;
+  const { radius = isRing ? roseType ? roseRingRadius : ringRadius : pieRadius } = settings;
+  const { legendVisible, t, tooltipVisible } = extra;
+  limitShowNum && innerRows.sort((a, b) => b[metrics] - a[metrics]);
+  const seriesParams = { dataType, digit, dimension, emphasis, innerRows, isRing, itemStyle };
+  Object.assign(seriesParams, { label, labelLine, legendName, level, limitShowNum, metrics, offsetY });
+  Object.assign(seriesParams, { percentShow, radius, roseType, selectedMode, t });
+  const series = getPieSeries(seriesParams);
+  const legendParams = { dimension, innerRows, legendLimit, legendName, level, limitShowNum, t };
+  const legend = legendVisible && getPieLegend(legendParams);
+  const pieTooltip = getPieTooltip({ dataType, innerRows, limitShowNum, digit, metrics, dimension, t });
+  const tooltip = tooltipVisible && pieTooltip;
+  const options = { legend, series, tooltip };
+  return options;
+};
+const ring = (columns, rows, settings, extra) => pie(columns, rows, settings, extra, true);
+export {
+  pie,
+  ring
+};

package/chart-radar/index.js

@@ -0,0 +1,105 @@
+import "../chunk-G2ADBYYC.js";
+import { getFormated } from "../chart-core/deps/utils";
+import { itemPoint, itemLabel, itemContent } from "../chart-core/deps/constants";
+import { isNull } from "../common/type";
+const getRadarLegend = (rows, dimension, legendName) => {
+  let legendData = rows.map((row) => row[dimension]).filter((i) => i);
+  function formatter(name) {
+    return isNull(legendName[name]) ? name : legendName[name];
+  }
+  return { data: legendData, formatter };
+};
+const getRadarTooltip = (dataType, radar2, digit) => {
+  const { typeTemp = [], nameTemp = [] } = {};
+  radar2.indicator.forEach((item, i) => {
+    typeTemp[i] = dataType[item.name];
+    nameTemp[i] = item.name;
+  });
+  function formatter(item) {
+    const tplt = [];
+    tplt.push(itemPoint(item.color));
+    tplt.push(`${item.name}<br />`);
+    item.data.value.forEach((val, i) => {
+      tplt.push(`${itemLabel(nameTemp[i])}`);
+      tplt.push(`${itemContent(getFormated(val, typeTemp[i], digit))}<br />`);
+    });
+    return tplt.join("");
+  }
+  return { formatter };
+};
+const getRadarSetting = (rows, metrics, labelMap) => {
+  const settingBase = {
+    indicator: [],
+    shape: "circle",
+    splitNumber: 5,
+    name: { textStyle: { color: "#191919" } },
+    splitLine: { lineStyle: { color: "rgba(25,25,25,0.10)" } },
+    splitArea: { show: false },
+    axisLine: { lineStyle: { color: "rgba(25,25,25,0.10)" } }
+  };
+  let indicatorTemp = {};
+  rows.forEach((items) => {
+    metrics.forEach((item) => {
+      const key = isNull(labelMap[item]) ? item : labelMap[item];
+      if (indicatorTemp[key]) {
+        indicatorTemp[key].push(items[item]);
+      } else {
+        indicatorTemp[key] = [items[item]];
+      }
+    });
+  });
+  settingBase.indicator = Object.keys(indicatorTemp).map((key) => ({
+    name: key,
+    max: Math.max.apply(null, indicatorTemp[key])
+  }));
+  return settingBase;
+};
+const getRadarSeries = (args) => {
+  const { areaStyle, dimension, itemStyle, label, labelMap, lineStyle, metrics, radar: radar2, rows } = args;
+  let radarIndexObj = {};
+  radar2.indicator.forEach((item, i) => radarIndexObj[item.name] = i);
+  const seriesData = rows.map((row) => {
+    const serieData = {
+      value: [],
+      name: row[dimension] || "",
+      symbol: "circle",
+      symbolSize: 8,
+      showSymbol: false,
+      emphasis: { itemStyle: { borderColor: "#fff", borderWidth: 2 } }
+    };
+    Object.keys(row).forEach((key) => {
+      if (~metrics.indexOf(key)) {
+        let k = isNull(labelMap[key]) ? radarIndexObj[key] : radarIndexObj[labelMap[key]];
+        serieData.value[k] = row[key];
+      }
+    });
+    return serieData;
+  });
+  const result = { data: seriesData, name: dimension, type: "radar", areaStyle: { normal: { opacity: 0.3 } } };
+  label && (result.label = label);
+  itemStyle && (result.itemStyle = itemStyle);
+  lineStyle && (result.lineStyle = lineStyle);
+  areaStyle && (result.areaStyle = areaStyle);
+  return [result];
+};
+const radar = (columns, rows, settings, extra) => {
+  const { dataType = {}, legendName = {}, labelMap = {}, dimension = columns[0] } = settings;
+  const { digit = 2, label, itemStyle, lineStyle, areaStyle } = settings;
+  const { tooltipVisible, legendVisible } = extra;
+  let metrics = columns.slice();
+  if (!settings.metrics) {
+    metrics.splice(columns.indexOf(dimension), 1);
+  } else {
+    metrics = settings.metrics;
+  }
+  const legend = legendVisible && getRadarLegend(rows, dimension, legendName);
+  const radar2 = getRadarSetting(rows, metrics, labelMap);
+  const tooltip = tooltipVisible && getRadarTooltip(dataType, radar2, digit);
+  const serieParams = { rows, dimension, metrics, radar: radar2 };
+  Object.assign(serieParams, { label, itemStyle, lineStyle, labelMap, areaStyle });
+  const series = getRadarSeries(serieParams);
+  return { legend, radar: radar2, series, tooltip };
+};
+export {
+  radar
+};

package/chart-sankey/index.js

@@ -0,0 +1,80 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-G2ADBYYC.js";
+import { getFormated } from "../chart-core/deps/utils";
+import { itemPoint, itemLabel, itemContent } from "../chart-core/deps/constants";
+import { isNull } from "../common/type";
+const getTooltip = (args) => {
+  const { digit, itemDataType, linksDataType } = args;
+  const formatter = function(item) {
+    const { name, data, value, color } = item;
+    const tplt = [];
+    color && tplt.push(itemPoint(color));
+    tplt.push(itemLabel(`${name}`));
+    if (!data || !data.source) {
+      tplt.push(`${itemContent(getFormated(value, itemDataType, digit))}<br />`);
+    } else {
+      tplt.push(`${itemContent(getFormated(value, linksDataType, digit))}<br />`);
+    }
+    return tplt.join("");
+  };
+  return { trigger: "item", formatter };
+};
+const getSeries = (args) => {
+  const { dimension, itemStyle, label, lineStyle, links, metrics, rows, useDataValue, valueFull } = args;
+  const dataMap = {};
+  const seriesData = rows.map((row) => {
+    dataMap[row[dimension]] = row[metrics];
+    return { name: row[dimension], value: row[metrics] };
+  });
+  let { innerLinks = links, mapHandler = null } = {};
+  if (useDataValue) {
+    mapHandler = (link) => __spreadProps(__spreadValues({}, link), { value: dataMap[link.target] });
+  } else if (!valueFull) {
+    mapHandler = (link) => isNull(link.value) ? __spreadProps(__spreadValues({}, link), { value: dataMap[link.target] }) : link;
+  }
+  if (mapHandler) {
+    innerLinks = links.map(mapHandler);
+  }
+  let result = { type: "sankey", data: seriesData, links: innerLinks, focusNodeAdjacency: "allEdges", nodeWidth: 12 };
+  result = Object.assign(result, { itemStyle: { opacity: 0.2 }, lineStyle: { opacity: 0.05 } });
+  let total = 0;
+  seriesData.forEach((item) => {
+    const isExist = innerLinks.some((data) => data.target === item.name);
+    if (!isExist) {
+      total += item.value;
+    }
+  });
+  const defaultLabel = {
+    backgroundColor: "transparent",
+    lineHeight: 16,
+    formatter(item) {
+      return `{name|${item.name}}
+{value|${Number(item.value / total).toFixed(2) * 100}%}`;
+    },
+    rich: { name: { color: "#4e4e4e" }, value: { color: "#818181", padding: [4, 0, 0, 0] } }
+  };
+  result.label = Object.assign(defaultLabel, label || {});
+  result.lineStyle = __spreadValues({
+    color: "source",
+    opacity: 0.5
+  }, lineStyle || {});
+  result.itemStyle = __spreadValues({ borderWidth: 0 }, itemStyle);
+  return [result];
+};
+const sankey = (columns, rows, settings) => {
+  const { dataType = ["normal", "normal"], dimension = columns[0], digit = 2, label } = settings;
+  const { links, lineStyle, itemStyle, metrics = columns[1], useDataValue = false, valueFull = false } = settings;
+  if (!links) {
+    return;
+  }
+  const { itemDataType = dataType[0], linksDataType = dataType[1] } = {};
+  const tooltip = getTooltip({ itemDataType, linksDataType, digit });
+  const seriesParams = { rows, dimension, metrics, links, valueFull, useDataValue, label, itemStyle, lineStyle };
+  const series = getSeries(seriesParams);
+  return { tooltip, series };
+};
+export {
+  sankey
+};

package/chart-scatter/index.js

@@ -0,0 +1,173 @@
+import {
+  __spreadValues
+} from "../chunk-G2ADBYYC.js";
+import { getFormated, hexToRgb } from "../chart-core/deps/utils";
+import { itemPoint, itemLabel, itemContent } from "../chart-core/deps/constants";
+import { line } from "../chart-line";
+import { isNull } from "../common/type";
+const getScatterLegend = (dataLabels, legendName) => {
+  function formatter(name) {
+    return isNull(legendName[name]) ? name : legendName[name];
+  }
+  return { data: dataLabels, formatter, itemStyle: { borderWidth: 1 } };
+};
+const getTooltipContent = (item, args) => {
+  const { labelMap, columns } = args;
+  const { dataType, digit } = args;
+  const template = [];
+  const { color, seriesName, data } = item;
+  const { value } = data;
+  template.push(`${itemPoint(color)} ${seriesName}<br>`);
+  value.forEach((d, i) => {
+    const name = labelMap[columns[i]] || columns[i];
+    const num = isNaN(d) ? d : getFormated(d, dataType[columns[i]], digit);
+    template.push(`${itemLabel(name)}${itemContent(num)}<br>`);
+  });
+  return template.join("");
+};
+const getScatterTooltip = (args) => {
+  const { tooltipTrigger } = args;
+  function formatter(item) {
+    return Array.isArray(item) ? item.map((i) => getTooltipContent(i, args)).join("") : getTooltipContent(item, args);
+  }
+  return { trigger: tooltipTrigger, formatter };
+};
+const getScatterXAxis = (args) => {
+  const { rows, dataLabels, dimension } = args;
+  const { xAxisName, axisVisible, xAxisType } = args;
+  const data = [];
+  dataLabels.forEach((dataLabel) => {
+    const items = rows[dataLabel];
+    items.forEach((item) => {
+      const name = item[dimension];
+      name && !~data.indexOf(name) && data.push(name);
+    });
+  });
+  return [
+    {
+      type: xAxisType,
+      show: axisVisible,
+      name: xAxisName,
+      data,
+      offset: 5,
+      axisLabel: { show: true, color: "#4E4E4E" }
+    }
+  ];
+};
+const getScatterYAxis = (args) => {
+  const { axisVisible, dataType, digit, min } = args;
+  const { metrics, max, scale, yAxisName } = args;
+  function formatter(val) {
+    return getFormated(val, dataType[metrics[0]], digit);
+  }
+  let result = { type: "value", show: axisVisible, scale, min, max };
+  Object.assign(result, {
+    axisTick: { show: false },
+    name: yAxisName,
+    offset: 10,
+    axisLabel: { show: true, formatter, color: "#4E4E4E" },
+    splitLine: { show: true, lineStyle: { color: "rgba(25,25,25,0.10)" } }
+  });
+  return result;
+};
+const getScatterSeries = (args) => {
+  const { columns, cursor, dataLabels, dimension, itemStyle, label, metrics, color } = args;
+  const { rows, symbol, symbolRotate, symbolSize, symbolSizeMax, symbolOffset } = args;
+  const extraMetrics = columns.filter((column) => !~metrics.indexOf(column) && column !== dimension);
+  const numbers = [];
+  dataLabels.forEach((dataLabel) => rows[dataLabel].forEach((row) => numbers.push(row[metrics[1]])));
+  const { maxNum = Math.max(...numbers), series = [] } = {};
+  dataLabels.forEach((dataLabel, index) => {
+    const { result = [], itemData = rows[dataLabel] } = {};
+    itemData.forEach((item) => {
+      const itemResult = { value: [] };
+      itemResult.value.push(item[dimension], item[metrics[0]], item[metrics[1]]);
+      extraMetrics.forEach((ext) => itemResult.value.push(item[ext]));
+      itemResult.symbolSize = symbolSize || item[metrics[1]] / maxNum * symbolSizeMax;
+      result.push(itemResult);
+    });
+    const serie = {
+      type: "scatter",
+      data: result,
+      name: dataLabel,
+      label,
+      itemStyle: __spreadValues({
+        borderWidth: 1,
+        borderColor: color[index],
+        color: `rgba(${hexToRgb(color[index])}, 0.3)`
+      }, itemStyle || {})
+    };
+    Object.assign(serie, { symbol, symbolRotate, symbolOffset, cursor });
+    series.push(serie);
+  });
+  return series;
+};
+const getSeries = (args) => {
+  const { cursor, label, tooltip, itemStyle, symbolSizeMax } = args;
+  const { series, color, symbol, symbolSize, symbolRotate, symbolOffset } = args;
+  series.forEach((item, index) => {
+    const itemBase = { type: "scatter", symbol };
+    const numbers = [];
+    const data = item.data;
+    data.forEach((row) => numbers.push(row[1]));
+    const maxNum = Math.max(...numbers);
+    item.data = data.map((item2) => ({
+      value: item2,
+      symbolSize: symbolSize || item2[1] / maxNum * symbolSizeMax
+    }));
+    Object.assign(itemBase, {
+      symbolRotate,
+      symbolOffset,
+      cursor,
+      label,
+      tooltip,
+      itemStyle: __spreadValues({
+        borderWidth: 1,
+        borderColor: color[index],
+        color: `rgba(${hexToRgb(color[index])}, 0.3)`
+      }, itemStyle || {}),
+      emphasis: { itemStyle: { borderWidth: 1, borderColor: color[index] } }
+    });
+    Object.assign(item, itemBase);
+  });
+  return series;
+};
+const scatter = (columns, rows, settings, extra) => {
+  const { dimension = columns[0], metrics = [columns[1], columns[2]], dataType = {} } = settings;
+  const { xAxisType = "category", xAxisName, yAxisName, digit = 2, legendName = {} } = settings;
+  const { labelMap = {}, tooltipTrigger = "item", axisVisible = true, symbolSizeMax = 50, symbol } = settings;
+  const { symbolSize, symbolRotate, symbolOffset, cursor, min, max, scale, label, itemStyle } = settings;
+  const { tooltipVisible, legendVisible, color } = extra;
+  const tooltip = tooltipVisible && getScatterTooltip({ tooltipTrigger, labelMap, columns, dataType, digit });
+  if (Array.isArray(rows)) {
+    const lineSettings = __spreadValues(__spreadValues({}, settings), {
+      yAxisName: yAxisName ? [yAxisName] : void 0,
+      xAxisName: xAxisName ? [xAxisName] : void 0,
+      dimension: dimension ? [dimension] : void 0,
+      max: max ? [max] : void 0,
+      min: min ? [min] : void 0,
+      scale: scale ? [scale] : void 0
+    });
+    const options = line(columns, rows, lineSettings, extra);
+    if (!options || !options.series) {
+      return {};
+    }
+    const baseObj = { color, symbol, symbolSize, symbolRotate, symbolOffset, cursor, label, itemStyle, symbolSizeMax };
+    options.series = getSeries(__spreadValues({ tooltip, series: options.series }, baseObj));
+    options.legend = __spreadValues({ itemStyle: { borderWidth: 1 } }, options.legend || {});
+    return options;
+  }
+  const dataLabels = Object.keys(rows);
+  const legend = legendVisible && getScatterLegend(dataLabels, legendName);
+  const xAxisParam = { xAxisName, axisVisible, xAxisType, dataLabels, dimension, rows };
+  const xAxis = getScatterXAxis(xAxisParam);
+  const yAxisParam = { min, max, scale, yAxisName, dataType, metrics, digit, axisVisible };
+  const yAxis = getScatterYAxis(yAxisParam);
+  const seriesParam = { rows, dataLabels, columns, metrics, dimension, label, itemStyle, symbol };
+  Object.assign(seriesParam, { symbolSizeMax, symbolSize, symbolRotate, symbolOffset, cursor, color });
+  const series = getScatterSeries(seriesParam);
+  return { legend, tooltip, xAxis, yAxis, series };
+};
+export {
+  scatter
+};

package/chart-sunburst/index.js

@@ -0,0 +1,28 @@
+import "../chunk-G2ADBYYC.js";
+import { itemPoint, itemLabel, itemContent } from "../chart-core/deps/constants";
+const getTooltip = () => ({
+  trigger: "item",
+  formatter(item) {
+    const tpl = [];
+    const { name, value, color } = item;
+    if (name) {
+      color && tpl.push(itemPoint(color));
+      tpl.push(`${itemLabel("label")}${itemContent(name)}`);
+      tpl.push("<br>");
+    }
+    color && tpl.push(itemPoint(color));
+    tpl.push(`${itemLabel("sum")}${itemContent(value)}`);
+    return tpl.join("");
+  }
+});
+const sunburst = (columns, rows, settings, extra) => {
+  const defaultItemStyle = { borderWidth: 2 };
+  const series = { type: "sunburst", itemStyle: defaultItemStyle };
+  const { tooltipVisible } = extra;
+  const tooltip = tooltipVisible && getTooltip({});
+  let options = { series, tooltip };
+  return options;
+};
+export {
+  sunburst
+};