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

package/chart-tree/index.js

@@ -1,68 +1,44 @@
-import { isObject } from '@opentiny/vue-renderless/chart-core/deps/utils';
-import { itemLabel, itemContent, SAAS_DEFAULT_COLORS_10 } from '@opentiny/vue-renderless/chart-core/deps/constants';
-var getTreeLegend = function getTreeLegend(args) {
-  var dimension = args.dimension,
-    rows = args.rows;
-  var result = rows.map(function (row) {
-    return row[dimension];
-  });
-  return {
-    data: result
-  };
+import "../chunk-PKUHTIDK.js";
+import { isObject } from "@opentiny/vue-renderless/chart-core/deps/utils";
+import { itemLabel, itemContent, SAAS_DEFAULT_COLORS_10 } from "@opentiny/vue-renderless/chart-core/deps/constants";
+const getTreeLegend = (args) => {
+  const { dimension, rows } = args;
+  const result = rows.map((row) => row[dimension]);
+  return { data: result };
 };
-var getTreeTooltip = function getTreeTooltip(args) {
-  var tooltipFormatter = args.tooltipFormatter;
+const getTreeTooltip = (args) => {
+  const { tooltipFormatter } = args;
   return {
-    trigger: 'item',
-    triggerOn: 'mousemove',
-    formatter: function formatter(item) {
+    trigger: "item",
+    triggerOn: "mousemove",
+    formatter(item) {
       if (tooltipFormatter) {
         return tooltipFormatter.apply(null, arguments);
       }
-      var template = [];
-      var treeAncestors = item.treeAncestors,
-        value = item.value;
-      var names = [];
-      treeAncestors.forEach(function (ancestor, idx) {
+      let template = [];
+      const { treeAncestors, value } = item;
+      let names = [];
+      treeAncestors.forEach((ancestor, idx) => {
         idx && names.push(ancestor.name);
       });
-      template.push("".concat(itemLabel(names.join('.'))));
-      template.push("".concat(itemContent(value)));
-      return template.join('');
+      template.push(`${itemLabel(names.join("."))}`);
+      template.push(`${itemContent(value)}`);
+      return template.join("");
     }
   };
 };
-var getTreeSeries = function getTreeSeries(args) {
-  var dimension = args.dimension,
-    metrics = args.metrics,
-    rows = args.rows,
-    seriesMap = args.seriesMap;
-  var series = [];
-  rows.forEach(function (row) {
-    var seriesItem = seriesMap[row[dimension]];
-    var label = {
-      position: 'right',
-      fontSize: 12,
-      color: '#191919'
-    };
-    var itemStyle = {
-      color: SAAS_DEFAULT_COLORS_10[0]
-    };
-    var lineStyle = {
-      color: 'rgba(25 ,25 ,25 , 0.10)'
-    };
-    var symbolSize = 16;
-    var result = {
-      type: 'tree',
-      name: row[dimension],
-      data: row[metrics],
-      itemStyle: itemStyle,
-      label: label,
-      lineStyle: lineStyle,
-      symbolSize: symbolSize
-    };
+const getTreeSeries = (args) => {
+  const { dimension, metrics, rows, seriesMap } = args;
+  const series = [];
+  rows.forEach((row) => {
+    const seriesItem = seriesMap[row[dimension]];
+    const label = { position: "right", fontSize: 12, color: "#191919" };
+    const itemStyle = { color: SAAS_DEFAULT_COLORS_10[0] };
+    const lineStyle = { color: "rgba(25 ,25 ,25 , 0.10)" };
+    const symbolSize = 16;
+    const result = { type: "tree", name: row[dimension], data: row[metrics], itemStyle, label, lineStyle, symbolSize };
     if (seriesItem) {
-      Object.keys(seriesItem).forEach(function (key) {
+      Object.keys(seriesItem).forEach((key) => {
         if (!isObject(result[key])) {
           result[key] = seriesItem[key];
         } else {
@@ -74,34 +50,16 @@ var getTreeSeries = function getTreeSeries(args) {
   });
   return series;
 };
-export var tree = function tree(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] : _settings$metrics,
-    _settings$seriesMap = settings.seriesMap,
-    seriesMap = _settings$seriesMap === void 0 ? {} : _settings$seriesMap;
-  var legendVisible = extra.legendVisible,
-    tooltipFormatter = extra.tooltipFormatter,
-    tooltipVisible = extra.tooltipVisible;
-  var seriesParam = {
-    dimension: dimension,
-    metrics: metrics,
-    rows: rows,
-    seriesMap: seriesMap
-  };
-  var series = getTreeSeries(seriesParam);
-  var legendParam = {
-    dimension: dimension,
-    rows: rows
-  };
-  var legend = legendVisible && rows.length > 1 && getTreeLegend(legendParam);
-  var tooltip = tooltipVisible && getTreeTooltip({
-    tooltipFormatter: tooltipFormatter
-  });
-  return {
-    series: series,
-    legend: legend,
-    tooltip: tooltip
-  };
-};
+const tree = (columns, rows, settings, extra) => {
+  const { dimension = columns[0], metrics = columns[1], seriesMap = {} } = settings;
+  const { legendVisible, tooltipFormatter, tooltipVisible } = extra;
+  const seriesParam = { dimension, metrics, rows, seriesMap };
+  const series = getTreeSeries(seriesParam);
+  const legendParam = { dimension, rows };
+  const legend = legendVisible && rows.length > 1 && getTreeLegend(legendParam);
+  const tooltip = tooltipVisible && getTreeTooltip({ tooltipFormatter });
+  return { series, legend, tooltip };
+};
+export {
+  tree
+};

package/chart-waterfall/index.js

@@ -1,231 +1,98 @@
-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 } from '@opentiny/vue-renderless/chart-core/deps/utils';
-import { isNull } from '@opentiny/vue-renderless/common/type';
-import { itemLabel, itemContent, SAAS_DEFAULT_COLORS_10 } from '@opentiny/vue-renderless/chart-core/deps/constants';
-var getWaterfallTooltip = function getWaterfallTooltip(dataType, digit) {
-  var trigger = 'axis';
-  var axisPointer = {
-    type: 'shadow'
-  };
-  var formatter = function formatter(items) {
-    var item = items[1];
-    return ["".concat(itemContent(item.name), "<br/>").concat(itemLabel(item.seriesName)), "".concat(itemContent(getFormated(item.value, dataType, digit)))].join('');
-  };
-  return {
-    trigger: trigger,
-    axisPointer: axisPointer,
-    formatter: formatter
-  };
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-PKUHTIDK.js";
+import { getFormated } from "@opentiny/vue-renderless/chart-core/deps/utils";
+import { isNull } from "@opentiny/vue-renderless/common/type";
+import { itemLabel, itemContent, SAAS_DEFAULT_COLORS_10 } from "@opentiny/vue-renderless/chart-core/deps/constants";
+const getWaterfallTooltip = (dataType, digit) => {
+  let trigger = "axis";
+  let axisPointer = { type: "shadow" };
+  let formatter = function(items) {
+    const item = items[1];
+    return [`${itemContent(item.name)}<br/>${itemLabel(item.seriesName)}`, `${itemContent(getFormated(item.value, dataType, digit))}`].join("");
+  };
+  return { trigger, axisPointer, formatter };
 };
-var getWaterfallXAxis = function getWaterfallXAxis(args) {
-  var axisVisible = args.axisVisible,
-    dimension = args.dimension,
-    labelMap = args.labelMap,
-    remainName = args.remainName,
-    remainStatus = args.remainStatus,
-    rows = args.rows,
-    totalName = args.totalName,
-    xAxisName = args.xAxisName;
-  var xAxisData = [totalName].concat(rows.map(function (row) {
-    return row[dimension];
-  }));
-  remainStatus === 'have-remain' && (xAxisData = xAxisData.concat([remainName]));
-  var name = labelMap && labelMap[xAxisName] || xAxisName;
-  var xAxis = {
-    type: 'category',
-    name: name,
-    splitLine: {
-      show: false
-    },
-    data: xAxisData,
-    show: axisVisible
-  };
-  var axisLine = {
-    show: true,
-    lineStyle: {
-      color: '#191919',
-      opacity: 0.1,
-      width: 2
-    }
-  };
-  var axisPointer = {
-    type: 'shadow',
-    z: 1,
-    shadowStyle: {
-      color: '#f5f5f5'
-    }
-  };
-  return _objectSpread(_objectSpread({}, xAxis), {}, {
-    axisLine: axisLine,
-    axisPointer: axisPointer
+const getWaterfallXAxis = (args) => {
+  const { axisVisible, dimension, labelMap, remainName, remainStatus, rows, totalName, xAxisName } = args;
+  let xAxisData = [totalName].concat(rows.map((row) => row[dimension]));
+  remainStatus === "have-remain" && (xAxisData = xAxisData.concat([remainName]));
+  let name = labelMap && labelMap[xAxisName] || xAxisName;
+  const xAxis = { type: "category", name, splitLine: { show: false }, data: xAxisData, show: axisVisible };
+  const axisLine = { show: true, lineStyle: { color: "#191919", opacity: 0.1, width: 2 } };
+  const axisPointer = { type: "shadow", z: 1, shadowStyle: { color: "#f5f5f5" } };
+  return __spreadProps(__spreadValues({}, xAxis), {
+    axisLine,
+    axisPointer
   });
 };
-var getWaterfallYAxis = function getWaterfallYAxis(args) {
-  var axisVisible = args.axisVisible,
-    dataType = args.dataType,
-    digit = args.digit,
-    labelMap = args.labelMap,
-    yAxisName = args.yAxisName;
-  var name = !isNull(labelMap[yAxisName]) ? labelMap[yAxisName] : yAxisName;
-  var formatter = function formatter(val) {
+const getWaterfallYAxis = (args) => {
+  const { axisVisible, dataType, digit, labelMap, yAxisName } = args;
+  let name = !isNull(labelMap[yAxisName]) ? labelMap[yAxisName] : yAxisName;
+  let formatter = function(val) {
     return getFormated(val, dataType, digit);
   };
-  return {
-    type: 'value',
-    name: name,
-    axisTick: {
-      show: false
-    },
-    axisLabel: {
-      formatter: formatter
-    },
-    show: axisVisible
-  };
+  return { type: "value", name, axisTick: { show: false }, axisLabel: { formatter }, show: axisVisible };
 };
-var getWaterfallSeries = function getWaterfallSeries(args) {
-  var dataSum = args.dataSum,
-    dataType = args.dataType,
-    digit = args.digit,
-    metrics = args.metrics,
-    remainStatus = args.remainStatus,
-    rows = args.rows,
-    t = args.t,
-    totalNum = args.totalNum;
-  var seriesBase = {
-    type: 'bar',
-    stack: t('ui.chart.summation')
-  };
-  var _ref = {},
-    _ref$dataSumTemp = _ref.dataSumTemp,
-    dataSumTemp = _ref$dataSumTemp === void 0 ? dataSum : _ref$dataSumTemp,
-    _ref$totalNumTemp = _ref.totalNumTemp,
-    totalNumTemp = _ref$totalNumTemp === void 0 ? totalNum : _ref$totalNumTemp,
-    assistData = _ref.assistData,
-    mainData = _ref.mainData;
-  var rowData = rows.map(function (row) {
-    return row[metrics];
-  });
-  if (remainStatus === 'have-remain') {
-    assistData = [0].concat(rows.map(function (row) {
-      return totalNumTemp -= row[metrics];
-    })).concat([0]);
+const getWaterfallSeries = (args) => {
+  const { dataSum, dataType, digit, metrics, remainStatus, rows, t, totalNum } = args;
+  const seriesBase = { type: "bar", stack: t("ui.chart.summation") };
+  let { dataSumTemp = dataSum, totalNumTemp = totalNum, assistData, mainData } = {};
+  const rowData = rows.map((row) => row[metrics]);
+  if (remainStatus === "have-remain") {
+    assistData = [0].concat(rows.map((row) => totalNumTemp -= row[metrics])).concat([0]);
     mainData = [totalNum].concat(rowData).concat([totalNum - dataSum]);
   } else {
-    assistData = [0].concat(rows.map(function (row) {
-      return dataSumTemp -= row[metrics];
-    }));
+    assistData = [0].concat(rows.map((row) => dataSumTemp -= row[metrics]));
     mainData = [dataSum].concat(rowData);
   }
-  var series = [];
-  var seriesAdv = {
-    name: t('ui.chart.auxiliary'),
-    itemStyle: {
-      opacity: 0
-    },
-    emphasis: {
-      itemStyle: {
-        opacity: 0
-      }
-    },
+  const series = [];
+  let seriesAdv = {
+    name: t("ui.chart.auxiliary"),
+    itemStyle: { opacity: 0 },
+    emphasis: { itemStyle: { opacity: 0 } },
     data: assistData
   };
   series.push(Object.assign(seriesAdv, seriesBase));
-  var formatter = function formatter(item) {
+  let formatter = function(item) {
     return getFormated(item.value, dataType, digit);
   };
   seriesAdv = {
-    name: t('ui.chart.value'),
-    label: {
-      show: true,
-      position: 'top',
-      formatter: formatter
-    },
+    name: t("ui.chart.value"),
+    label: { show: true, position: "top", formatter },
     data: mainData
   };
-  series.push(Object.assign(seriesAdv, _objectSpread(_objectSpread({}, seriesBase), {}, {
-    itemStyle: {
-      borderRadius: [4, 4, 0, 0]
-    },
-    color: SAAS_DEFAULT_COLORS_10[0]
-  })));
+  series.push(
+    Object.assign(seriesAdv, __spreadProps(__spreadValues({}, seriesBase), {
+      itemStyle: { borderRadius: [4, 4, 0, 0] },
+      color: SAAS_DEFAULT_COLORS_10[0]
+    }))
+  );
   return series;
 };
-var getWaterfallRemainStatus = function getWaterfallRemainStatus(dataSum, totalNum) {
-  return !totalNum ? 'not-total' : totalNum <= dataSum ? 'none-remain' : 'have-remain';
-};
-export var waterfall = function waterfall(columns, rows, settings, extra) {
-  var tooltipVisible = extra.tooltipVisible,
-    t = extra.t;
-  var _settings$axisVisible = settings.axisVisible,
-    axisVisible = _settings$axisVisible === void 0 ? true : _settings$axisVisible,
-    _settings$dataType = settings.dataType,
-    dataType = _settings$dataType === void 0 ? 'normal' : _settings$dataType,
-    _settings$dimension = settings.dimension,
-    dimension = _settings$dimension === void 0 ? columns[0] : _settings$dimension;
-  var _settings$remainName = settings.remainName,
-    remainName = _settings$remainName === void 0 ? t('ui.chart.other') : _settings$remainName,
-    _settings$totalName = settings.totalName,
-    totalName = _settings$totalName === void 0 ? t('ui.chart.total') : _settings$totalName;
-  var totalNum = settings.totalNum,
-    _settings$xAxisName = settings.xAxisName,
-    xAxisName = _settings$xAxisName === void 0 ? dimension : _settings$xAxisName,
-    _settings$digit = settings.digit,
-    digit = _settings$digit === void 0 ? 2 : _settings$digit,
-    _settings$labelMap = settings.labelMap,
-    labelMap = _settings$labelMap === void 0 ? {} : _settings$labelMap;
-  var metricsTemp = columns.slice();
+const getWaterfallRemainStatus = (dataSum, totalNum) => !totalNum ? "not-total" : totalNum <= dataSum ? "none-remain" : "have-remain";
+const waterfall = (columns, rows, settings, extra) => {
+  const { tooltipVisible, t } = extra;
+  const { axisVisible = true, dataType = "normal", dimension = columns[0] } = settings;
+  const { remainName = t("ui.chart.other"), totalName = t("ui.chart.total") } = settings;
+  const { totalNum, xAxisName = dimension, digit = 2, labelMap = {} } = settings;
+  let metricsTemp = columns.slice();
   metricsTemp.splice(metricsTemp.indexOf(dimension), 1);
-  var _ref2 = {},
-    _ref2$metrics = _ref2.metrics,
-    metrics = _ref2$metrics === void 0 ? metricsTemp[0] : _ref2$metrics,
-    _ref2$yAxisName = _ref2.yAxisName,
-    yAxisName = _ref2$yAxisName === void 0 ? metrics : _ref2$yAxisName;
-  var tooltip = tooltipVisible && getWaterfallTooltip(dataType, digit);
-  var dataSum = parseFloat(rows.reduce(function (pre, cur) {
-    return pre + Number(cur[metrics]);
-  }, 0).toFixed(digit));
-  var remainStatus = getWaterfallRemainStatus(dataSum, totalNum);
-  var xAxisParams = {
-    dimension: dimension,
-    rows: rows,
-    remainStatus: remainStatus,
-    totalName: totalName
-  };
-  Object.assign(xAxisParams, {
-    remainName: remainName,
-    xAxisName: xAxisName,
-    labelMap: labelMap,
-    axisVisible: axisVisible
-  });
-  var xAxis = getWaterfallXAxis(xAxisParams);
-  var yAxisParams = {
-    dataType: dataType,
-    yAxisName: yAxisName,
-    axisVisible: axisVisible,
-    digit: digit,
-    labelMap: labelMap
-  };
-  var yAxis = getWaterfallYAxis(yAxisParams);
-  var seriesParams = {
-    dataType: dataType,
-    rows: rows,
-    dimension: dimension,
-    metrics: metrics
-  };
-  Object.assign(seriesParams, {
-    totalNum: totalNum,
-    remainStatus: remainStatus,
-    dataSum: dataSum,
-    digit: digit,
-    t: t
-  });
-  var series = getWaterfallSeries(seriesParams);
-  return {
-    series: series,
-    tooltip: tooltip,
-    xAxis: xAxis,
-    yAxis: yAxis
-  };
-};
+  const { metrics = metricsTemp[0], yAxisName = metrics } = {};
+  const tooltip = tooltipVisible && getWaterfallTooltip(dataType, digit);
+  const dataSum = parseFloat(rows.reduce((pre, cur) => pre + Number(cur[metrics]), 0).toFixed(digit));
+  const remainStatus = getWaterfallRemainStatus(dataSum, totalNum);
+  const xAxisParams = { dimension, rows, remainStatus, totalName };
+  Object.assign(xAxisParams, { remainName, xAxisName, labelMap, axisVisible });
+  const xAxis = getWaterfallXAxis(xAxisParams);
+  const yAxisParams = { dataType, yAxisName, axisVisible, digit, labelMap };
+  const yAxis = getWaterfallYAxis(yAxisParams);
+  const seriesParams = { dataType, rows, dimension, metrics };
+  Object.assign(seriesParams, { totalNum, remainStatus, dataSum, digit, t });
+  const series = getWaterfallSeries(seriesParams);
+  return { series, tooltip, xAxis, yAxis };
+};
+export {
+  waterfall
+};

package/chart-wordcloud/index.js

@@ -1,43 +1,25 @@
-import { random } from '@opentiny/vue-renderless/common/string';
-import { itemLabel, itemContent } from '@opentiny/vue-renderless/chart-core/deps/constants';
-var isArr = Array.isArray;
-var getSeries = function getSeries(args) {
-  var color = args.color,
-    dimension = args.dimension,
-    metrics = args.metrics,
-    rows = args.rows,
-    shape = args.shape,
-    sizeMax = args.sizeMax,
-    sizeMin = args.sizeMin;
-  var normalColor;
+import "../chunk-PKUHTIDK.js";
+import { random } from "@opentiny/vue-renderless/common/string";
+import { itemLabel, itemContent } from "@opentiny/vue-renderless/chart-core/deps/constants";
+const isArr = Array.isArray;
+const getSeries = (args) => {
+  const { color, dimension, metrics, rows, shape, sizeMax, sizeMin } = args;
+  let normalColor;
   if (!isArr(color) && !!color) {
     normalColor = color;
   } else {
-    normalColor = function normalColor() {
-      var rgb = [Math.round(random() * 160), Math.round(random() * 160), Math.round(random() * 160)].join(',');
-      return 'rgb(' + rgb + ')';
+    normalColor = () => {
+      const rgb = [Math.round(random() * 160), Math.round(random() * 160), Math.round(random() * 160)].join(",");
+      return "rgb(" + rgb + ")";
     };
   }
-  var textStyle = {
-    normal: {
-      color: normalColor
-    },
-    color: normalColor
-  };
-  var baseType = {
-    type: 'wordCloud',
-    textStyle: textStyle,
-    shape: shape,
-    sizeRange: [sizeMin, sizeMax]
-  };
-  var len = isArr(color) ? color.length : 0;
-  baseType.data = rows.slice().map(function (row, i) {
-    var text = {
-      name: row[dimension],
-      value: row[metrics]
-    };
+  let textStyle = { normal: { color: normalColor }, color: normalColor };
+  const baseType = { type: "wordCloud", textStyle, shape, sizeRange: [sizeMin, sizeMax] };
+  const len = isArr(color) ? color.length : 0;
+  baseType.data = rows.slice().map((row, i) => {
+    const text = { name: row[dimension], value: row[metrics] };
     if (len > 0) {
-      var wordColor = color[i % len];
+      let wordColor = color[i % len];
       text.textStyle = {
         normal: {
           color: wordColor
@@ -47,63 +29,32 @@ var getSeries = function getSeries(args) {
     }
     return text;
   });
-  Object.assign(baseType, {
-    rotationRange: [0, 0],
-    gridSize: 10
-  });
+  Object.assign(baseType, { rotationRange: [0, 0], gridSize: 10 });
   return [baseType];
 };
-var getTooltip = function getTooltip(args) {
-  var tooltipFormatter = args.tooltipFormatter;
+const getTooltip = (args) => {
+  const { tooltipFormatter } = args;
   function formatter(params) {
-    var data = params.data;
-    var name = data.name,
-      value = data.value;
+    const { data } = params;
+    const { name, value } = data;
     if (tooltipFormatter) {
       return tooltipFormatter.apply(null, params);
     }
-    return "".concat(itemLabel(name)).concat(itemContent(value));
+    return `${itemLabel(name)}${itemContent(value)}`;
   }
-  return {
-    show: true,
-    formatter: formatter
-  };
+  return { show: true, formatter };
 };
-var shapeSquare = function shapeSquare(theta) {
-  return Math.min(1 / Math.abs(Math.cos(theta)), 1 / Math.abs(Math.sin(theta)));
+const shapeSquare = (theta) => Math.min(1 / Math.abs(Math.cos(theta)), 1 / Math.abs(Math.sin(theta)));
+const wordcloud = (columns, rows, settings, extra) => {
+  const { dimension = columns[0], metrics = columns[1], color = "" } = settings;
+  const { sizeMax = 60, sizeMin = 12, shape } = settings;
+  const { tooltipVisible, tooltipFormatter, color: colors } = extra;
+  const seriesParams = { dimension, metrics, rows, sizeMax, sizeMin };
+  Object.assign(seriesParams, { color: color || colors, shape: shape || shapeSquare });
+  const series = getSeries(seriesParams);
+  const tooltip = tooltipVisible && getTooltip({ tooltipFormatter });
+  return { series, tooltip };
+};
+export {
+  wordcloud
 };
-export var wordcloud = function wordcloud(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] : _settings$metrics,
-    _settings$color = settings.color,
-    color = _settings$color === void 0 ? '' : _settings$color;
-  var _settings$sizeMax = settings.sizeMax,
-    sizeMax = _settings$sizeMax === void 0 ? 60 : _settings$sizeMax,
-    _settings$sizeMin = settings.sizeMin,
-    sizeMin = _settings$sizeMin === void 0 ? 12 : _settings$sizeMin,
-    shape = settings.shape;
-  var tooltipVisible = extra.tooltipVisible,
-    tooltipFormatter = extra.tooltipFormatter,
-    colors = extra.color;
-  var seriesParams = {
-    dimension: dimension,
-    metrics: metrics,
-    rows: rows,
-    sizeMax: sizeMax,
-    sizeMin: sizeMin
-  };
-  Object.assign(seriesParams, {
-    color: color || colors,
-    shape: shape || shapeSquare
-  });
-  var series = getSeries(seriesParams);
-  var tooltip = tooltipVisible && getTooltip({
-    tooltipFormatter: tooltipFormatter
-  });
-  return {
-    series: series,
-    tooltip: tooltip
-  };
-};