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

package/chart-heatmap/index.js

@@ -1,407 +1,161 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _toArray from "@babel/runtime/helpers/toArray";
-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, getBmap, getAmap, getMapJSON } from '@opentiny/vue-renderless/chart-core/deps/utils';
-import { HEAT_MAP_COLOR, itemPoint, itemLabel, itemContent } from '@opentiny/vue-renderless/chart-core/deps/constants';
-var getAxisList = function getAxisList(rows, label) {
-  var result = [];
-  rows.forEach(function (row) {
-    return result.indexOf(row[label]) === -1 && result.push(row[label]);
-  });
+import {
+  __spreadValues
+} from "../chunk-PKUHTIDK.js";
+import { getFormated, getBmap, getAmap, getMapJSON } from "@opentiny/vue-renderless/chart-core/deps/utils";
+import { HEAT_MAP_COLOR, itemPoint, itemLabel, itemContent } from "@opentiny/vue-renderless/chart-core/deps/constants";
+const getAxisList = (rows, label) => {
+  const result = [];
+  rows.forEach((row) => !result.includes(row[label]) && result.push(row[label]));
   return result;
 };
-var getData = function getData(args) {
-  var extraMetrics = args.extraMetrics,
-    innerXAxisList = args.innerXAxisList,
-    innerYAxisList = args.innerYAxisList,
-    metrics = args.metrics,
-    rows = args.rows,
-    type = args.type,
-    xDim = args.xDim,
-    yDim = args.yDim;
-  var result = null;
-  if (type !== 'cartesian') {
-    result = rows.map(function (row) {
-      return {
-        value: [row[xDim], row[yDim], metrics ? row[metrics] : 1]
-      };
-    });
+const getData = (args) => {
+  const { extraMetrics, innerXAxisList, innerYAxisList, metrics, rows, type, xDim, yDim } = args;
+  let result = null;
+  if (type !== "cartesian") {
+    result = rows.map((row) => ({ value: [row[xDim], row[yDim], metrics ? row[metrics] : 1] }));
   } else {
-    result = rows.map(function (row) {
-      var _ref = {},
-        xIndex = _ref.xIndex,
-        yIndex = _ref.yIndex,
-        value = _ref.value,
-        extra = _ref.extra;
+    result = rows.map((row) => {
+      let { xIndex, yIndex, value, extra } = {};
       yIndex = innerYAxisList.indexOf(row[yDim]);
       xIndex = innerXAxisList.indexOf(row[xDim]);
-      extra = extraMetrics.map(function (m) {
-        return row[m] || '-';
-      });
+      extra = extraMetrics.map((m) => row[m] || "-");
       value = metrics ? row[metrics] : 1;
-      return {
-        value: [xIndex, yIndex, value].concat(extra),
-        label: {
-          show: true,
-          color: '#191919'
-        }
-      };
+      return { value: [xIndex, yIndex, value].concat(extra), label: { show: true, color: "#191919" } };
     });
   }
   return result;
 };
-var getAxis = function getAxis(list, name, type) {
-  return {
-    data: list,
-    name: name,
-    nameLocation: 'end',
-    type: 'category',
-    splitArea: {
-      show: false
-    },
-    splitLine: {
-      show: true,
-      lineStyle: {
-        color: '#6d8ff0'
-      }
-    },
-    axisLabel: {
-      show: true,
-      color: '#4E4E4E'
-    },
-    offset: type === 'y' ? 25 : 5,
-    zlevel: 1
-  };
-};
-var getVisualMap = function getVisualMap(args) {
-  var min = args.innerMin,
-    max = args.innerMax,
-    type = args.type,
-    heatColor = args.heatColor,
-    series = args.series;
-  var _ref2 = {},
-    extra = _ref2.extra;
-  if (type === 'map') {
+let getAxis = (list, name, type) => ({
+  data: list,
+  name,
+  nameLocation: "end",
+  type: "category",
+  splitArea: { show: false },
+  splitLine: { show: true, lineStyle: { color: "#6d8ff0" } },
+  axisLabel: { show: true, color: "#4E4E4E" },
+  offset: type === "y" ? 25 : 5,
+  zlevel: 1
+});
+const getVisualMap = (args) => {
+  const { innerMin: min, innerMax: max, type, heatColor, series } = args;
+  let { extra } = {};
+  if (type === "map") {
     extra = {};
     !series[0].data.length && (extra.show = false);
-  } else if (type === 'bmap' || type === 'amap') {
-    extra = {
-      show: false
-    };
+  } else if (type === "bmap" || type === "amap") {
+    extra = { show: false };
   } else {
-    extra = {
-      dimension: 2
-    };
+    extra = { dimension: 2 };
   }
-  var defaultColor = type === 'map' || type === 'bmap' || type === 'amap' ? HEAT_MAP_COLOR : ['#fff', '#6D8FF0'];
+  const defaultColor = type === "map" || type === "bmap" || type === "amap" ? HEAT_MAP_COLOR : ["#fff", "#6D8FF0"];
   return Object.assign(extra, {
-    min: min,
-    max: max,
+    min,
+    max,
     calculable: true,
-    left: 'right',
-    bottom: 'center',
-    orient: 'vertical',
-    align: 'left',
-    borderColor: '#6D8FF0',
+    left: "right",
+    bottom: "center",
+    orient: "vertical",
+    align: "left",
+    borderColor: "#6D8FF0",
     inverse: true,
-    inRange: {
-      color: heatColor || defaultColor
-    }
+    inRange: { color: heatColor || defaultColor }
   });
 };
-var getSeries = function getSeries(args) {
-  return [{
-    type: 'heatmap',
-    data: args.chartData
-  }];
-};
-var getTooltip = function getTooltip(args) {
-  var dataType = args.dataType,
-    innerXAxisList = args.innerXAxisList,
-    innerYAxisList = args.innerYAxisList,
-    digit = args.digit,
-    extraMetrics = args.extraMetrics,
-    metrics = args.metrics;
-  function formatter(_ref3) {
-    var color = _ref3.color,
-      data = _ref3.data;
-    var dataVal = data.value;
-    var _dataVal = _toArray(dataVal),
-      xDim = _dataVal[0],
-      yDim = _dataVal[1],
-      value = _dataVal[2],
-      extraData = _dataVal.slice(3);
-    var tplt = [itemContent("".concat(innerXAxisList[xDim], " ~ ").concat(innerYAxisList[yDim], "<br>"))];
-    extraMetrics.forEach(function (m, index) {
-      return tplt.push("".concat(m, ": ").concat(extraData[index], "<br>"));
-    });
-    tplt.push("".concat(itemPoint(color)).concat(itemLabel(metrics)).concat(itemContent(getFormated(value, dataType, digit)), "<br>"));
-    return tplt.join('');
+const getSeries = (args) => [{ type: "heatmap", data: args.chartData }];
+const getTooltip = (args) => {
+  const { dataType, innerXAxisList, innerYAxisList, digit, extraMetrics, metrics } = args;
+  function formatter({ color, data }) {
+    let { value: dataVal } = data;
+    let [xDim, yDim, value, ...extraData] = dataVal;
+    const tplt = [itemContent(`${innerXAxisList[xDim]} ~ ${innerYAxisList[yDim]}<br>`)];
+    extraMetrics.forEach((m, index) => tplt.push(`${m}: ${extraData[index]}<br>`));
+    tplt.push(`${itemPoint(color)}${itemLabel(metrics)}${itemContent(getFormated(value, dataType, digit))}<br>`);
+    return tplt.join("");
   }
-  return {
-    trigger: 'item',
-    formatter: formatter
-  };
+  return { trigger: "item", formatter };
 };
-var fixParam = function fixParam(_ref4) {
-  var type = _ref4.type,
-    rows = _ref4.rows,
-    dimension = _ref4.dimension,
-    metrics = _ref4.metrics,
-    extraMetrics = _ref4.extraMetrics,
-    chartData = _ref4.chartData,
-    innerXAxisList = _ref4.innerXAxisList,
-    innerYAxisList = _ref4.innerYAxisList;
-  var chartDataParams;
-  if (type !== 'cartesian') {
-    chartDataParams = {
-      rows: rows,
-      xDim: dimension[0],
-      yDim: dimension[1]
-    };
-    Object.assign(chartDataParams, {
-      metrics: metrics,
-      type: type,
-      extraMetrics: extraMetrics
-    });
+const fixParam = ({ type, rows, dimension, metrics, extraMetrics, chartData, innerXAxisList, innerYAxisList }) => {
+  let chartDataParams;
+  if (type !== "cartesian") {
+    chartDataParams = { rows, xDim: dimension[0], yDim: dimension[1] };
+    Object.assign(chartDataParams, { metrics, type, extraMetrics });
     chartData = getData(chartDataParams);
   } else {
-    var flag = !innerXAxisList || !innerXAxisList.length;
+    let flag = !innerXAxisList || !innerXAxisList.length;
     flag && (innerXAxisList = getAxisList(rows, dimension[0]));
     flag = !innerYAxisList || !innerYAxisList.length;
     flag && (innerYAxisList = getAxisList(rows, dimension[1]));
-    chartDataParams = {
-      xDim: dimension[0],
-      yDim: dimension[1],
-      rows: rows
-    };
-    Object.assign(chartDataParams, {
-      innerXAxisList: innerXAxisList,
-      innerYAxisList: innerYAxisList,
-      metrics: metrics,
-      type: type,
-      extraMetrics: extraMetrics
-    });
+    chartDataParams = { xDim: dimension[0], yDim: dimension[1], rows };
+    Object.assign(chartDataParams, { innerXAxisList, innerYAxisList, metrics, type, extraMetrics });
     chartData = getData(chartDataParams);
   }
-  return {
-    chartData: chartData,
-    innerXAxisList: innerXAxisList,
-    innerYAxisList: innerYAxisList
-  };
+  return { chartData, innerXAxisList, innerYAxisList };
 };
-var getResult = function getResult(args) {
-  var type = args.type,
-    options = args.options,
-    pointSize = args.pointSize,
-    blurSize = args.blurSize,
-    res = args.res,
-    key = args.key,
-    v = args.v,
-    bmap = args.bmap,
-    mapOrigin = args.mapOrigin,
-    geo = args.geo,
-    beforeRegisterMap = args.beforeRegisterMap;
-  var echarts = args.echarts,
-    specialAreas = args.specialAreas,
-    position = args.position,
-    positionJsonLink = args.positionJsonLink,
-    beforeRegisterMapOnce = args.beforeRegisterMapOnce;
-  var mapURLProfix = args.mapURLProfix,
-    amap = args.amap,
-    tooltip = args.tooltip,
-    xAxis = args.xAxis,
-    yAxis = args.yAxis;
-  if (type === 'bmap') {
-    Object.assign(options.series[0], {
-      coordinateSystem: 'bmap',
-      pointSize: pointSize,
-      blurSize: blurSize
-    });
-    res = getBmap(key, v).then(function () {
-      return _objectSpread({
-        bmap: bmap
-      }, options);
-    });
-  } else if (type === 'map') {
-    options.series[0].coordinateSystem = 'geo';
-    var json = mapOrigin;
+const getResult = (args) => {
+  let { type, options, pointSize, blurSize, res, key, v, bmap, mapOrigin, geo, beforeRegisterMap } = args;
+  let { echarts, specialAreas, position, positionJsonLink, beforeRegisterMapOnce } = args;
+  let { mapURLProfix, amap, tooltip, xAxis, yAxis } = args;
+  if (type === "bmap") {
+    Object.assign(options.series[0], { coordinateSystem: "bmap", pointSize, blurSize });
+    res = getBmap(key, v).then(() => __spreadValues({ bmap }, options));
+  } else if (type === "map") {
+    options.series[0].coordinateSystem = "geo";
+    let json = mapOrigin;
     if (json) {
-      var geoAttr = _objectSpread({
-        map: mapOrigin
-      }, geo);
+      const geoAttr = __spreadValues({ map: mapOrigin }, geo);
       beforeRegisterMap && (json = beforeRegisterMap(json));
       echarts.registerMap(mapOrigin, json, specialAreas);
-      res = new Promise(function (resolve) {
-        return resolve(_objectSpread({
-          geo: geoAttr
-        }, options));
-      });
+      res = new Promise((resolve) => resolve(__spreadValues({ geo: geoAttr }, options)));
     } else {
-      var params = {
-        position: position,
-        positionJsonLink: positionJsonLink,
-        beforeRegisterMapOnce: beforeRegisterMapOnce,
-        mapURLProfix: mapURLProfix
-      };
-      res = getMapJSON(params).then(function (json) {
-        var geoAttr = _objectSpread({
-          map: position
-        }, geo);
-        beforeRegisterMap && (json = beforeRegisterMap(json));
-        echarts.registerMap(position, json, specialAreas);
-        return _objectSpread({
-          geo: geoAttr
-        }, options);
+      let params = { position, positionJsonLink, beforeRegisterMapOnce, mapURLProfix };
+      res = getMapJSON(params).then((json2) => {
+        const geoAttr = __spreadValues({ map: position }, geo);
+        beforeRegisterMap && (json2 = beforeRegisterMap(json2));
+        echarts.registerMap(position, json2, specialAreas);
+        return __spreadValues({ geo: geoAttr }, options);
       });
     }
-  } else if (type === 'amap') {
-    Object.assign(options.series[0], {
-      coordinateSystem: 'amap',
-      pointSize: pointSize,
-      blurSize: blurSize
-    });
-    res = getAmap(key, v).then(function () {
-      return _objectSpread({
-        amap: amap
-      }, options);
-    });
+  } else if (type === "amap") {
+    Object.assign(options.series[0], { coordinateSystem: "amap", pointSize, blurSize });
+    res = getAmap(key, v).then(() => __spreadValues({ amap }, options));
   } else {
-    res = _objectSpread({
-      tooltip: tooltip,
-      xAxis: xAxis,
-      yAxis: yAxis
-    }, options);
+    res = __spreadValues({ tooltip, xAxis, yAxis }, options);
   }
   return res;
 };
-export var heatmap = function heatmap(columns, rows, settings, extra) {
-  var _settings$type = settings.type,
-    type = _settings$type === void 0 ? 'cartesian' : _settings$type;
-  var _settings$dimension = settings.dimension,
-    dimension = _settings$dimension === void 0 ? [columns[0], columns[1]] : _settings$dimension;
-  var _settings$dataType = settings.dataType,
-    dataType = _settings$dataType === void 0 ? 'normal' : _settings$dataType,
-    min = settings.min,
-    max = settings.max,
-    digit = settings.digit,
-    bmap = settings.bmap,
-    amap = settings.amap,
-    geo = settings.geo,
-    key = settings.key,
-    _settings$v = settings.v,
-    v = _settings$v === void 0 ? '2.0' : _settings$v;
-  var position = settings.position,
-    mapOrigin = settings.mapOrigin,
-    positionJsonLink = settings.positionJsonLink,
-    beforeRegisterMap = settings.beforeRegisterMap,
-    _settings$pointSize = settings.pointSize,
-    pointSize = _settings$pointSize === void 0 ? 10 : _settings$pointSize,
-    _settings$blurSize = settings.blurSize,
-    blurSize = _settings$blurSize === void 0 ? 5 : _settings$blurSize;
-  var heatColor = settings.heatColor,
-    yAxisName = settings.yAxisName,
-    xAxisName = settings.xAxisName,
-    beforeRegisterMapOnce = settings.beforeRegisterMapOnce,
-    _settings$specialArea = settings.specialAreas,
-    specialAreas = _settings$specialArea === void 0 ? {} : _settings$specialArea;
-  var _settings$metrics = settings.metrics,
-    metrics = _settings$metrics === void 0 ? columns[2] : _settings$metrics,
-    _settings$mapURLProfi = settings.mapURLProfix,
-    mapURLProfix = _settings$mapURLProfi === void 0 ? 'https://unpkg.com/echarts@3.6.2/map/json/' : _settings$mapURLProfi;
-  var tooltipVisible = extra.tooltipVisible,
-    echarts = extra.echartsLib;
-  var innerXAxisList = settings.xAxisList,
-    innerYAxisList = settings.yAxisList;
-  var _ref5 = {},
-    _ref5$chartData = _ref5.chartData,
-    chartData = _ref5$chartData === void 0 ? [] : _ref5$chartData,
-    _ref5$extraMetrics = _ref5.extraMetrics,
-    extraMetrics = _ref5$extraMetrics === void 0 ? [] : _ref5$extraMetrics,
-    _ref5$mainColumn = _ref5.mainColumn,
-    mainColumn = _ref5$mainColumn === void 0 ? dimension.concat([metrics]) : _ref5$mainColumn;
-  columns.forEach(function (column) {
-    return !~mainColumn.indexOf(column) && extraMetrics.push(column);
-  });
-  var ret = fixParam({
-    type: type,
-    rows: rows,
-    dimension: dimension,
-    metrics: metrics,
-    extraMetrics: extraMetrics,
-    chartData: chartData,
-    innerXAxisList: innerXAxisList,
-    innerYAxisList: innerYAxisList
-  });
+const heatmap = (columns, rows, settings, extra) => {
+  const { type = "cartesian" } = settings;
+  const { dimension = [columns[0], columns[1]] } = settings;
+  const { dataType = "normal", min, max, digit, bmap, amap, geo, key, v = "2.0" } = settings;
+  const { position, mapOrigin, positionJsonLink, beforeRegisterMap, pointSize = 10, blurSize = 5 } = settings;
+  const { heatColor, yAxisName, xAxisName, beforeRegisterMapOnce, specialAreas = {} } = settings;
+  const { metrics = columns[2], mapURLProfix = "https://unpkg.com/echarts@3.6.2/map/json/" } = settings;
+  const { tooltipVisible, echartsLib: echarts } = extra;
+  let { xAxisList: innerXAxisList, yAxisList: innerYAxisList } = settings;
+  let { chartData = [], extraMetrics = [], mainColumn = dimension.concat([metrics]) } = {};
+  columns.forEach((column) => !~mainColumn.indexOf(column) && extraMetrics.push(column));
+  let ret = fixParam({ type, rows, dimension, metrics, extraMetrics, chartData, innerXAxisList, innerYAxisList });
   chartData = ret.chartData;
   innerXAxisList = ret.innerXAxisList;
   innerYAxisList = ret.innerYAxisList;
-  var metricsList = metrics ? rows.map(function (row) {
-    return row[metrics];
-  }) : [0, 5];
+  let metricsList = metrics ? rows.map((row) => row[metrics]) : [0, 5];
   !metricsList.length && (metricsList = [0]);
-  var innerMin = min || Math.min.apply(null, metricsList);
-  var innerMax = max || Math.max.apply(null, metricsList);
-  var xAxis = getAxis(innerXAxisList, xAxisName, 'x');
-  var yAxis = getAxis(innerYAxisList, yAxisName, 'y');
-  var series = getSeries({
-    chartData: chartData
-  });
-  var visualMap = getVisualMap({
-    innerMin: innerMin,
-    innerMax: innerMax,
-    type: type,
-    heatColor: heatColor,
-    series: series
-  });
-  var tooltipParams = {
-    dataType: dataType,
-    innerXAxisList: innerXAxisList,
-    innerYAxisList: innerYAxisList,
-    digit: digit,
-    extraMetrics: extraMetrics,
-    metrics: metrics
-  };
-  var tooltip = tooltipVisible && getTooltip(tooltipParams);
-  var options = {
-    visualMap: visualMap,
-    series: series,
-    grid: {
-      left: 25,
-      right: 80,
-      width: 'auto',
-      height: 'auto'
-    }
-  };
-  var res;
-  var args = {
-    type: type,
-    options: options,
-    pointSize: pointSize,
-    blurSize: blurSize,
-    res: res,
-    key: key,
-    v: v,
-    bmap: bmap,
-    mapOrigin: mapOrigin,
-    geo: geo,
-    beforeRegisterMap: beforeRegisterMap
-  };
-  Object.assign(args, {
-    echarts: echarts,
-    specialAreas: specialAreas,
-    position: position,
-    positionJsonLink: positionJsonLink,
-    beforeRegisterMapOnce: beforeRegisterMapOnce
-  });
-  Object.assign(args, {
-    mapURLProfix: mapURLProfix,
-    amap: amap,
-    tooltip: tooltip,
-    xAxis: xAxis,
-    yAxis: yAxis
-  });
+  const innerMin = min || Math.min.apply(null, metricsList);
+  const innerMax = max || Math.max.apply(null, metricsList);
+  const xAxis = getAxis(innerXAxisList, xAxisName, "x");
+  const yAxis = getAxis(innerYAxisList, yAxisName, "y");
+  const series = getSeries({ chartData });
+  const visualMap = getVisualMap({ innerMin, innerMax, type, heatColor, series });
+  const tooltipParams = { dataType, innerXAxisList, innerYAxisList, digit, extraMetrics, metrics };
+  const tooltip = tooltipVisible && getTooltip(tooltipParams);
+  const options = { visualMap, series, grid: { left: 25, right: 80, width: "auto", height: "auto" } };
+  let res;
+  let args = { type, options, pointSize, blurSize, res, key, v, bmap, mapOrigin, geo, beforeRegisterMap };
+  Object.assign(args, { echarts, specialAreas, position, positionJsonLink, beforeRegisterMapOnce });
+  Object.assign(args, { mapURLProfix, amap, tooltip, xAxis, yAxis });
   res = getResult(args);
   return res;
-};
+};
+export {
+  heatmap
+};