@opentiny/vue-renderless 3.6.0 → 3.6.1-alpha.2

package/chart-scatter/index.js

@@ -1,360 +1,165 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-import { getFormated, hexToRgb } from '@opentiny/vue-renderless/chart-core/deps/utils';
-import { itemPoint, itemLabel, itemContent } from '@opentiny/vue-renderless/chart-core/deps/constants';
-import { line } from '@opentiny/vue-renderless/chart-line';
-import { isNull } from '@opentiny/vue-renderless/common/type';
-var getScatterLegend = function getScatterLegend(dataLabels, legendName) {
+import {
+  __spreadValues
+} from "../chunk-PKUHTIDK.js";
+import { getFormated, hexToRgb } from "@opentiny/vue-renderless/chart-core/deps/utils";
+import { itemPoint, itemLabel, itemContent } from "@opentiny/vue-renderless/chart-core/deps/constants";
+import { line } from "@opentiny/vue-renderless/chart-line";
+import { isNull } from "@opentiny/vue-renderless/common/type";
+const getScatterLegend = (dataLabels, legendName) => {
   function formatter(name) {
     return isNull(legendName[name]) ? name : legendName[name];
   }
-  return {
-    data: dataLabels,
-    formatter: formatter,
-    itemStyle: {
-      borderWidth: 1
-    }
-  };
+  return { data: dataLabels, formatter, itemStyle: { borderWidth: 1 } };
 };
-var getTooltipContent = function getTooltipContent(item, args) {
-  var labelMap = args.labelMap,
-    columns = args.columns;
-  var dataType = args.dataType,
-    digit = args.digit;
-  var template = [];
-  var color = item.color,
-    seriesName = item.seriesName,
-    data = item.data;
-  var value = data.value;
-  template.push("".concat(itemPoint(color), " ").concat(seriesName, "<br>"));
-  value.forEach(function (d, i) {
-    var name = labelMap[columns[i]] || columns[i];
-    var num = isNaN(d) ? d : getFormated(d, dataType[columns[i]], digit);
-    template.push("".concat(itemLabel(name)).concat(itemContent(num), "<br>"));
+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('');
+  return template.join("");
 };
-var getScatterTooltip = function getScatterTooltip(args) {
-  var tooltipTrigger = args.tooltipTrigger;
+const getScatterTooltip = (args) => {
+  const { tooltipTrigger } = args;
   function formatter(item) {
-    return Array.isArray(item) ? item.map(function (i) {
-      return getTooltipContent(i, args);
-    }).join('') : getTooltipContent(item, args);
+    return Array.isArray(item) ? item.map((i) => getTooltipContent(i, args)).join("") : getTooltipContent(item, args);
   }
-  return {
-    trigger: tooltipTrigger,
-    formatter: formatter
-  };
+  return { trigger: tooltipTrigger, formatter };
 };
-var getScatterXAxis = function getScatterXAxis(args) {
-  var rows = args.rows,
-    dataLabels = args.dataLabels,
-    dimension = args.dimension;
-  var xAxisName = args.xAxisName,
-    axisVisible = args.axisVisible,
-    xAxisType = args.xAxisType;
-  var data = [];
-  dataLabels.forEach(function (dataLabel) {
-    var items = rows[dataLabel];
-    items.forEach(function (item) {
-      var name = item[dimension];
+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: data,
-    offset: 5,
-    axisLabel: {
-      show: true,
-      color: '#4E4E4E'
+  return [
+    {
+      type: xAxisType,
+      show: axisVisible,
+      name: xAxisName,
+      data,
+      offset: 5,
+      axisLabel: { show: true, color: "#4E4E4E" }
     }
-  }];
+  ];
 };
-var getScatterYAxis = function getScatterYAxis(args) {
-  var axisVisible = args.axisVisible,
-    dataType = args.dataType,
-    digit = args.digit,
-    min = args.min;
-  var metrics = args.metrics,
-    max = args.max,
-    scale = args.scale,
-    yAxisName = args.yAxisName;
+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);
   }
-  var result = {
-    type: 'value',
-    show: axisVisible,
-    scale: scale,
-    min: min,
-    max: max
-  };
+  let result = { type: "value", show: axisVisible, scale, min, max };
   Object.assign(result, {
-    axisTick: {
-      show: false
-    },
+    axisTick: { show: false },
     name: yAxisName,
     offset: 10,
-    axisLabel: {
-      show: true,
-      formatter: formatter,
-      color: '#4E4E4E'
-    },
-    splitLine: {
-      show: true,
-      lineStyle: {
-        color: 'rgba(25,25,25,0.10)'
-      }
-    }
+    axisLabel: { show: true, formatter, color: "#4E4E4E" },
+    splitLine: { show: true, lineStyle: { color: "rgba(25,25,25,0.10)" } }
   });
   return result;
 };
-var getScatterSeries = function getScatterSeries(args) {
-  var columns = args.columns,
-    cursor = args.cursor,
-    dataLabels = args.dataLabels,
-    dimension = args.dimension,
-    itemStyle = args.itemStyle,
-    label = args.label,
-    metrics = args.metrics,
-    color = args.color;
-  var rows = args.rows,
-    symbol = args.symbol,
-    symbolRotate = args.symbolRotate,
-    symbolSize = args.symbolSize,
-    symbolSizeMax = args.symbolSizeMax,
-    symbolOffset = args.symbolOffset;
-  var extraMetrics = columns.filter(function (column) {
-    return !~metrics.indexOf(column) && column !== dimension;
-  });
-  var numbers = [];
-  dataLabels.forEach(function (dataLabel) {
-    return rows[dataLabel].forEach(function (row) {
-      return numbers.push(row[metrics[1]]);
-    });
-  });
-  var _ref = {},
-    _ref$maxNum = _ref.maxNum,
-    maxNum = _ref$maxNum === void 0 ? Math.max.apply(Math, numbers) : _ref$maxNum,
-    _ref$series = _ref.series,
-    series = _ref$series === void 0 ? [] : _ref$series;
-  dataLabels.forEach(function (dataLabel, index) {
-    var _ref2 = {},
-      _ref2$result = _ref2.result,
-      result = _ref2$result === void 0 ? [] : _ref2$result,
-      _ref2$itemData = _ref2.itemData,
-      itemData = _ref2$itemData === void 0 ? rows[dataLabel] : _ref2$itemData;
-    itemData.forEach(function (item) {
-      var itemResult = {
-        value: []
-      };
+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(function (ext) {
-        return itemResult.value.push(item[ext]);
-      });
+      extraMetrics.forEach((ext) => itemResult.value.push(item[ext]));
       itemResult.symbolSize = symbolSize || item[metrics[1]] / maxNum * symbolSizeMax;
       result.push(itemResult);
     });
-    var serie = {
-      type: 'scatter',
+    const serie = {
+      type: "scatter",
       data: result,
       name: dataLabel,
-      label: label,
-      itemStyle: _objectSpread({
-        borderWidth: 1,
-        borderColor: color[index],
-        color: "rgba(".concat(hexToRgb(color[index]), ", 0.3)")
-      }, itemStyle || {})
+      label,
+      itemStyle: __spreadValues({ borderWidth: 1, borderColor: color[index], color: `rgba(${hexToRgb(color[index])}, 0.3)` }, itemStyle || {})
     };
-    Object.assign(serie, {
-      symbol: symbol,
-      symbolRotate: symbolRotate,
-      symbolOffset: symbolOffset,
-      cursor: cursor
-    });
+    Object.assign(serie, { symbol, symbolRotate, symbolOffset, cursor });
     series.push(serie);
   });
   return series;
 };
-var getSeries = function getSeries(args) {
-  var cursor = args.cursor,
-    label = args.label,
-    tooltip = args.tooltip,
-    itemStyle = args.itemStyle,
-    symbolSizeMax = args.symbolSizeMax;
-  var series = args.series,
-    color = args.color,
-    symbol = args.symbol,
-    symbolSize = args.symbolSize,
-    symbolRotate = args.symbolRotate,
-    symbolOffset = args.symbolOffset;
-  series.forEach(function (item, index) {
-    var itemBase = {
-      type: 'scatter',
-      symbol: symbol
-    };
-    var numbers = [];
-    var data = item.data;
-    data.forEach(function (row) {
-      return numbers.push(row[1]);
-    });
-    var maxNum = Math.max.apply(Math, numbers);
-    item.data = data.map(function (item) {
-      return {
-        value: item,
-        symbolSize: symbolSize || item[1] / maxNum * symbolSizeMax
-      };
-    });
+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: symbolRotate,
-      symbolOffset: symbolOffset,
-      cursor: cursor,
-      label: label,
-      tooltip: tooltip,
-      itemStyle: _objectSpread({
-        borderWidth: 1,
-        borderColor: color[index],
-        color: "rgba(".concat(hexToRgb(color[index]), ", 0.3)")
-      }, itemStyle || {}),
-      emphasis: {
-        itemStyle: {
-          borderWidth: 1,
-          borderColor: color[index]
-        }
-      }
+      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;
 };
-export var scatter = function scatter(columns, rows, settings, extra) {
-  var _settings$dimension = settings.dimension,
-    dimension = _settings$dimension === void 0 ? columns[0] : _settings$dimension,
-    _settings$metrics = settings.metrics,
-    metrics = _settings$metrics === void 0 ? [columns[1], columns[2]] : _settings$metrics,
-    _settings$dataType = settings.dataType,
-    dataType = _settings$dataType === void 0 ? {} : _settings$dataType;
-  var _settings$xAxisType = settings.xAxisType,
-    xAxisType = _settings$xAxisType === void 0 ? 'category' : _settings$xAxisType,
-    xAxisName = settings.xAxisName,
-    yAxisName = settings.yAxisName,
-    _settings$digit = settings.digit,
-    digit = _settings$digit === void 0 ? 2 : _settings$digit,
-    _settings$legendName = settings.legendName,
-    legendName = _settings$legendName === void 0 ? {} : _settings$legendName;
-  var _settings$labelMap = settings.labelMap,
-    labelMap = _settings$labelMap === void 0 ? {} : _settings$labelMap,
-    _settings$tooltipTrig = settings.tooltipTrigger,
-    tooltipTrigger = _settings$tooltipTrig === void 0 ? 'item' : _settings$tooltipTrig,
-    _settings$axisVisible = settings.axisVisible,
-    axisVisible = _settings$axisVisible === void 0 ? true : _settings$axisVisible,
-    _settings$symbolSizeM = settings.symbolSizeMax,
-    symbolSizeMax = _settings$symbolSizeM === void 0 ? 50 : _settings$symbolSizeM,
-    symbol = settings.symbol;
-  var symbolSize = settings.symbolSize,
-    symbolRotate = settings.symbolRotate,
-    symbolOffset = settings.symbolOffset,
-    cursor = settings.cursor,
-    min = settings.min,
-    max = settings.max,
-    scale = settings.scale,
-    label = settings.label,
-    itemStyle = settings.itemStyle;
-  var tooltipVisible = extra.tooltipVisible,
-    legendVisible = extra.legendVisible,
-    color = extra.color;
-  var tooltip = tooltipVisible && getScatterTooltip({
-    tooltipTrigger: tooltipTrigger,
-    labelMap: labelMap,
-    columns: columns,
-    dataType: dataType,
-    digit: digit
-  });
+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)) {
-    var lineSettings = _objectSpread(_objectSpread({}, settings), {
-      yAxisName: yAxisName ? [yAxisName] : undefined,
-      xAxisName: xAxisName ? [xAxisName] : undefined,
-      dimension: dimension ? [dimension] : undefined,
-      max: max ? [max] : undefined,
-      min: min ? [min] : undefined,
-      scale: scale ? [scale] : undefined
+    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
     });
-    var options = line(columns, rows, lineSettings, extra);
+    const options = line(columns, rows, lineSettings, extra);
     if (!options || !options.series) {
       return {};
     }
-    var baseObj = {
-      color: color,
-      symbol: symbol,
-      symbolSize: symbolSize,
-      symbolRotate: symbolRotate,
-      symbolOffset: symbolOffset,
-      cursor: cursor,
-      label: label,
-      itemStyle: itemStyle,
-      symbolSizeMax: symbolSizeMax
-    };
-    options.series = getSeries(_objectSpread({
-      tooltip: tooltip,
-      series: options.series
-    }, baseObj));
-    options.legend = _objectSpread({
-      itemStyle: {
-        borderWidth: 1
-      }
-    }, options.legend || {});
+    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;
   }
-  var dataLabels = Object.keys(rows);
-  var legend = legendVisible && getScatterLegend(dataLabels, legendName);
-  var xAxisParam = {
-    xAxisName: xAxisName,
-    axisVisible: axisVisible,
-    xAxisType: xAxisType,
-    dataLabels: dataLabels,
-    dimension: dimension,
-    rows: rows
-  };
-  var xAxis = getScatterXAxis(xAxisParam);
-  var yAxisParam = {
-    min: min,
-    max: max,
-    scale: scale,
-    yAxisName: yAxisName,
-    dataType: dataType,
-    metrics: metrics,
-    digit: digit,
-    axisVisible: axisVisible
-  };
-  var yAxis = getScatterYAxis(yAxisParam);
-  var seriesParam = {
-    rows: rows,
-    dataLabels: dataLabels,
-    columns: columns,
-    metrics: metrics,
-    dimension: dimension,
-    label: label,
-    itemStyle: itemStyle,
-    symbol: symbol
-  };
-  Object.assign(seriesParam, {
-    symbolSizeMax: symbolSizeMax,
-    symbolSize: symbolSize,
-    symbolRotate: symbolRotate,
-    symbolOffset: symbolOffset,
-    cursor: cursor,
-    color: color
-  });
-  var series = getScatterSeries(seriesParam);
-  return {
-    legend: legend,
-    tooltip: tooltip,
-    xAxis: xAxis,
-    yAxis: yAxis,
-    series: series
-  };
-};
+  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

@@ -1,36 +1,28 @@
-import { itemPoint, itemLabel, itemContent } from '@opentiny/vue-renderless/chart-core/deps/constants';
-var getTooltip = function getTooltip() {
-  return {
-    trigger: 'item',
-    formatter: function formatter(item) {
-      var tpl = [];
-      var name = item.name,
-        value = item.value,
-        color = item.color;
-      if (name) {
-        color && tpl.push(itemPoint(color));
-        tpl.push("".concat(itemLabel('label')).concat(itemContent(name)));
-        tpl.push('<br>');
-      }
+import "../chunk-PKUHTIDK.js";
+import { itemPoint, itemLabel, itemContent } from "@opentiny/vue-renderless/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("".concat(itemLabel('sum')).concat(itemContent(value)));
-      return tpl.join('');
+      tpl.push(`${itemLabel("label")}${itemContent(name)}`);
+      tpl.push("<br>");
     }
-  };
-};
-export var sunburst = function sunburst(columns, rows, settings, extra) {
-  var defaultItemStyle = {
-    borderWidth: 2
-  };
-  var series = {
-    type: 'sunburst',
-    itemStyle: defaultItemStyle
-  };
-  var tooltipVisible = extra.tooltipVisible;
-  var tooltip = tooltipVisible && getTooltip({});
-  var options = {
-    series: series,
-    tooltip: tooltip
-  };
+    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
+};