@opentiny/vue-renderless 3.1.0-alpha.0 → 3.5.0

package/chart-radar/index.js

@@ -0,0 +1,181 @@
+import { getFormated } from '@opentiny/vue-renderless/chart-core/deps/utils';
+import { itemPoint, itemLabel, itemContent } from '@opentiny/vue-renderless/chart-core/deps/constants';
+import { isNull } from '@opentiny/vue-renderless/common/type';
+var getRadarLegend = function getRadarLegend(rows, dimension, legendName) {
+  var legendData = rows.map(function (row) {
+    return row[dimension];
+  });
+  function formatter(name) {
+    return isNull(legendName[name]) ? name : legendName[name];
+  }
+  return {
+    data: legendData,
+    formatter: formatter
+  };
+};
+var getRadarTooltip = function getRadarTooltip(dataType, radar, digit) {
+  var _ref = {},
+    _ref$typeTemp = _ref.typeTemp,
+    typeTemp = _ref$typeTemp === void 0 ? [] : _ref$typeTemp,
+    _ref$nameTemp = _ref.nameTemp,
+    nameTemp = _ref$nameTemp === void 0 ? [] : _ref$nameTemp;
+  radar.indicator.forEach(function (item, i) {
+    typeTemp[i] = dataType[item.name];
+    nameTemp[i] = item.name;
+  });
+  function formatter(item) {
+    var tplt = [];
+    tplt.push(itemPoint(item.color));
+    tplt.push("".concat(item.name, "<br />"));
+    item.data.value.forEach(function (val, i) {
+      tplt.push("".concat(itemLabel(nameTemp[i])));
+      tplt.push("".concat(itemContent(getFormated(val, typeTemp[i], digit)), "<br />"));
+    });
+    return tplt.join('');
+  }
+  return {
+    formatter: formatter
+  };
+};
+var getRadarSetting = function getRadarSetting(rows, metrics, labelMap) {
+  var 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)'
+      }
+    }
+  };
+  var indicatorTemp = {};
+  rows.forEach(function (items) {
+    metrics.forEach(function (item) {
+      var 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(function (key) {
+    return {
+      name: key,
+      max: Math.max.apply(null, indicatorTemp[key])
+    };
+  });
+  return settingBase;
+};
+var getRadarSeries = function getRadarSeries(args) {
+  var areaStyle = args.areaStyle,
+    dimension = args.dimension,
+    itemStyle = args.itemStyle,
+    label = args.label,
+    labelMap = args.labelMap,
+    lineStyle = args.lineStyle,
+    metrics = args.metrics,
+    radar = args.radar,
+    rows = args.rows;
+  var radarIndexObj = {};
+  radar.indicator.forEach(function (item, i) {
+    return radarIndexObj[item.name] = i;
+  });
+  var seriesData = rows.map(function (row) {
+    var serieData = {
+      value: [],
+      name: row[dimension],
+      symbol: 'circle',
+      symbolSize: 8,
+      showSymbol: false,
+      emphasis: {
+        itemStyle: {
+          borderColor: '#fff',
+          borderWidth: 2
+        }
+      }
+    };
+    Object.keys(row).forEach(function (key) {
+      if (~metrics.indexOf(key)) {
+        var k = isNull(labelMap[key]) ? radarIndexObj[key] : radarIndexObj[labelMap[key]];
+        serieData.value[k] = row[key];
+      }
+    });
+    return serieData;
+  });
+  var 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];
+};
+export var radar = function radar(columns, rows, settings, extra) {
+  var _settings$dataType = settings.dataType,
+    dataType = _settings$dataType === void 0 ? {} : _settings$dataType,
+    _settings$legendName = settings.legendName,
+    legendName = _settings$legendName === void 0 ? {} : _settings$legendName,
+    _settings$labelMap = settings.labelMap,
+    labelMap = _settings$labelMap === void 0 ? {} : _settings$labelMap,
+    _settings$dimension = settings.dimension,
+    dimension = _settings$dimension === void 0 ? columns[0] : _settings$dimension;
+  var _settings$digit = settings.digit,
+    digit = _settings$digit === void 0 ? 2 : _settings$digit,
+    label = settings.label,
+    itemStyle = settings.itemStyle,
+    lineStyle = settings.lineStyle,
+    areaStyle = settings.areaStyle;
+  var tooltipVisible = extra.tooltipVisible,
+    legendVisible = extra.legendVisible;
+  var metrics = columns.slice();
+  if (!settings.metrics) {
+    metrics.splice(columns.indexOf(dimension), 1);
+  } else {
+    metrics = settings.metrics;
+  }
+  var legend = legendVisible && getRadarLegend(rows, dimension, legendName);
+  var radar = getRadarSetting(rows, metrics, labelMap);
+  var tooltip = tooltipVisible && getRadarTooltip(dataType, radar, digit);
+  var serieParams = {
+    rows: rows,
+    dimension: dimension,
+    metrics: metrics,
+    radar: radar
+  };
+  Object.assign(serieParams, {
+    label: label,
+    itemStyle: itemStyle,
+    lineStyle: lineStyle,
+    labelMap: labelMap,
+    areaStyle: areaStyle
+  });
+  var series = getRadarSeries(serieParams);
+  return {
+    legend: legend,
+    radar: radar,
+    series: series,
+    tooltip: tooltip
+  };
+};

package/chart-sankey/index.js

@@ -0,0 +1,166 @@
+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 { itemPoint, itemLabel, itemContent } from '@opentiny/vue-renderless/chart-core/deps/constants';
+import { isNull } from '@opentiny/vue-renderless/common/type';
+var getTooltip = function getTooltip(args) {
+  var digit = args.digit,
+    itemDataType = args.itemDataType,
+    linksDataType = args.linksDataType;
+  var formatter = function formatter(item) {
+    var name = item.name,
+      data = item.data,
+      value = item.value,
+      color = item.color;
+    var tplt = [];
+    color && tplt.push(itemPoint(color));
+    tplt.push(itemLabel("".concat(name)));
+    if (!data || !data.source) {
+      tplt.push("".concat(itemContent(getFormated(value, itemDataType, digit)), "<br />"));
+    } else {
+      tplt.push("".concat(itemContent(getFormated(value, linksDataType, digit)), "<br />"));
+    }
+    return tplt.join('');
+  };
+  return {
+    trigger: 'item',
+    formatter: formatter
+  };
+};
+var getSeries = function getSeries(args) {
+  var dimension = args.dimension,
+    itemStyle = args.itemStyle,
+    label = args.label,
+    lineStyle = args.lineStyle,
+    links = args.links,
+    metrics = args.metrics,
+    rows = args.rows,
+    useDataValue = args.useDataValue,
+    valueFull = args.valueFull;
+  var dataMap = {};
+  var seriesData = rows.map(function (row) {
+    dataMap[row[dimension]] = row[metrics];
+    return {
+      name: row[dimension],
+      value: row[metrics]
+    };
+  });
+  var _ref = {},
+    _ref$innerLinks = _ref.innerLinks,
+    innerLinks = _ref$innerLinks === void 0 ? links : _ref$innerLinks,
+    _ref$mapHandler = _ref.mapHandler,
+    mapHandler = _ref$mapHandler === void 0 ? null : _ref$mapHandler;
+  if (useDataValue) {
+    mapHandler = function mapHandler(link) {
+      return _objectSpread(_objectSpread({}, link), {}, {
+        value: dataMap[link.target]
+      });
+    };
+  } else if (!valueFull) {
+    mapHandler = function mapHandler(link) {
+      return isNull(link.value) ? _objectSpread(_objectSpread({}, link), {}, {
+        value: dataMap[link.target]
+      }) : link;
+    };
+  }
+  if (mapHandler) {
+    innerLinks = links.map(mapHandler);
+  }
+  var result = {
+    type: 'sankey',
+    data: seriesData,
+    links: innerLinks,
+    focusNodeAdjacency: 'allEdges',
+    nodeWidth: 12
+  };
+  result = Object.assign(result, {
+    itemStyle: {
+      opacity: 0.2
+    },
+    lineStyle: {
+      opacity: 0.05
+    }
+  });
+  var total = 0;
+  seriesData.forEach(function (item) {
+    var isExist = innerLinks.some(function (data) {
+      return data.target === item.name;
+    });
+    if (!isExist) {
+      total += item.value;
+    }
+  });
+  var defaultLabel = {
+    backgroundColor: 'transparent',
+    lineHeight: 16,
+    formatter: function formatter(item) {
+      return "{name|".concat(item.name, "}\n{value|").concat(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 = _objectSpread({
+    color: 'source',
+    opacity: 0.5
+  }, lineStyle || {});
+  result.itemStyle = _objectSpread({
+    borderWidth: 0
+  }, itemStyle);
+  return [result];
+};
+export var sankey = function sankey(columns, rows, settings) {
+  var _settings$dataType = settings.dataType,
+    dataType = _settings$dataType === void 0 ? ['normal', 'normal'] : _settings$dataType,
+    _settings$dimension = settings.dimension,
+    dimension = _settings$dimension === void 0 ? columns[0] : _settings$dimension,
+    _settings$digit = settings.digit,
+    digit = _settings$digit === void 0 ? 2 : _settings$digit,
+    label = settings.label;
+  var links = settings.links,
+    lineStyle = settings.lineStyle,
+    itemStyle = settings.itemStyle,
+    _settings$metrics = settings.metrics,
+    metrics = _settings$metrics === void 0 ? columns[1] : _settings$metrics,
+    _settings$useDataValu = settings.useDataValue,
+    useDataValue = _settings$useDataValu === void 0 ? false : _settings$useDataValu,
+    _settings$valueFull = settings.valueFull,
+    valueFull = _settings$valueFull === void 0 ? false : _settings$valueFull;
+  if (!links) {
+    return;
+  }
+  var _ref2 = {},
+    _ref2$itemDataType = _ref2.itemDataType,
+    itemDataType = _ref2$itemDataType === void 0 ? dataType[0] : _ref2$itemDataType,
+    _ref2$linksDataType = _ref2.linksDataType,
+    linksDataType = _ref2$linksDataType === void 0 ? dataType[1] : _ref2$linksDataType;
+  var tooltip = getTooltip({
+    itemDataType: itemDataType,
+    linksDataType: linksDataType,
+    digit: digit
+  });
+  var seriesParams = {
+    rows: rows,
+    dimension: dimension,
+    metrics: metrics,
+    links: links,
+    valueFull: valueFull,
+    useDataValue: useDataValue,
+    label: label,
+    itemStyle: itemStyle,
+    lineStyle: lineStyle
+  };
+  var series = getSeries(seriesParams);
+  return {
+    tooltip: tooltip,
+    series: series
+  };
+};

package/chart-scatter/index.js

@@ -0,0 +1,360 @@
+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) {
+  function formatter(name) {
+    return isNull(legendName[name]) ? name : legendName[name];
+  }
+  return {
+    data: dataLabels,
+    formatter: 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>"));
+  });
+  return template.join('');
+};
+var getScatterTooltip = function getScatterTooltip(args) {
+  var tooltipTrigger = args.tooltipTrigger;
+  function formatter(item) {
+    return Array.isArray(item) ? item.map(function (i) {
+      return getTooltipContent(i, args);
+    }).join('') : getTooltipContent(item, args);
+  }
+  return {
+    trigger: tooltipTrigger,
+    formatter: 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];
+      name && !~data.indexOf(name) && data.push(name);
+    });
+  });
+  return [{
+    type: xAxisType,
+    show: axisVisible,
+    name: xAxisName,
+    data: 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;
+  function formatter(val) {
+    return getFormated(val, dataType[metrics[0]], digit);
+  }
+  var result = {
+    type: 'value',
+    show: axisVisible,
+    scale: scale,
+    min: min,
+    max: max
+  };
+  Object.assign(result, {
+    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)'
+      }
+    }
+  });
+  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: []
+      };
+      itemResult.value.push(item[dimension], item[metrics[0]], item[metrics[1]]);
+      extraMetrics.forEach(function (ext) {
+        return itemResult.value.push(item[ext]);
+      });
+      itemResult.symbolSize = symbolSize || item[metrics[1]] / maxNum * symbolSizeMax;
+      result.push(itemResult);
+    });
+    var 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 || {})
+    };
+    Object.assign(serie, {
+      symbol: symbol,
+      symbolRotate: symbolRotate,
+      symbolOffset: symbolOffset,
+      cursor: 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
+      };
+    });
+    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]
+        }
+      }
+    });
+    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
+  });
+  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
+    });
+    var 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 || {});
+    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
+  };
+};