@anov/3d-ability 0.0.140 → 0.0.141

package/dist/business/HeatMap/core.js

@@ -1,19 +1,9 @@
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-var HeatmapConfig = {
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+const HeatmapConfig = {
   defaultRadius: 40,
   defaultRenderer: 'canvas2d',
   defaultGradient: {
@@ -30,9 +20,8 @@ var HeatmapConfig = {
   defaultValueField: 'value',
   plugins: {}
 };
-var Store = /*#__PURE__*/function () {
-  function Store(config) {
-    _classCallCheck(this, Store);
+class Store {
+  constructor(config) {
     _defineProperty(this, "_coordinator", {});
     _defineProperty(this, "_data", []);
     _defineProperty(this, "_radi", []);
@@ -47,177 +36,147 @@ var Store = /*#__PURE__*/function () {
     this._valueField = config.valueField || config.defaultValueField;
     if (config.radius) this._cfgRadius = config.radius;
   }
-  _createClass(Store, [{
-    key: "_organiseData",
-    value: function _organiseData(dataPoint, forceRender) {
-      var x = dataPoint[this._xField];
-      var y = dataPoint[this._yField];
-      var radi = this._radi;
-      var store = this._data;
-      var max = this._max;
-      var min = this._min;
-      var value = dataPoint[this._valueField] || 1;
-      var radius = dataPoint.radius || this._cfgRadius || HeatmapConfig.defaultRadius;
-      if (!store[x]) {
-        store[x] = [];
-        radi[x] = [];
-      }
-      if (!store[x][y]) {
-        store[x][y] = value;
-        radi[x][y] = radius;
-      } else {
-        store[x][y] += value;
-      }
-      var storedVal = store[x][y];
-      if (storedVal > max) {
-        if (!forceRender) this._max = storedVal;else this.setDataMax(storedVal);
-        return false;
-      } else if (storedVal < min) {
-        if (!forceRender) this._min = storedVal;else this.setDataMin(storedVal);
-        return false;
-      } else {
-        return {
-          x: x,
-          y: y,
-          value: value,
-          radius: radius,
-          min: min,
-          max: max
-        };
-      }
-    }
-  }, {
-    key: "_unOrganizeData",
-    value: function _unOrganizeData() {
-      var unorganizedData = [];
-      var data = this._data;
-      var radi = this._radi;
-      for (var x in data) {
-        for (var y in data[x]) {
-          unorganizedData.push({
-            x: x,
-            y: y,
-            radius: radi[x][y],
-            value: data[x][y]
-          });
-        }
-      }
+  _organiseData(dataPoint, forceRender) {
+    const x = dataPoint[this._xField];
+    const y = dataPoint[this._yField];
+    const radi = this._radi;
+    const store = this._data;
+    const max = this._max;
+    const min = this._min;
+    const value = dataPoint[this._valueField] || 1;
+    const radius = dataPoint.radius || this._cfgRadius || HeatmapConfig.defaultRadius;
+    if (!store[x]) {
+      store[x] = [];
+      radi[x] = [];
+    }
+    if (!store[x][y]) {
+      store[x][y] = value;
+      radi[x][y] = radius;
+    } else {
+      store[x][y] += value;
+    }
+    const storedVal = store[x][y];
+    if (storedVal > max) {
+      if (!forceRender) this._max = storedVal;else this.setDataMax(storedVal);
+      return false;
+    } else if (storedVal < min) {
+      if (!forceRender) this._min = storedVal;else this.setDataMin(storedVal);
+      return false;
+    } else {
       return {
-        min: this._min,
-        max: this._max,
-        data: unorganizedData
+        x,
+        y,
+        value,
+        radius,
+        min,
+        max
       };
     }
-  }, {
-    key: "_onExtremaChange",
-    value: function _onExtremaChange() {
-      this._coordinator.emit('extremachange', {
-        min: this._min,
-        max: this._max
-      });
-    }
-  }, {
-    key: "addData",
-    value: function addData() {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
+  }
+  _unOrganizeData() {
+    const unorganizedData = [];
+    const data = this._data;
+    const radi = this._radi;
+    for (const x in data) {
+      for (const y in data[x]) {
+        unorganizedData.push({
+          x,
+          y,
+          radius: radi[x][y],
+          value: data[x][y]
+        });
       }
-      if (args[0].length > 0) {
-        var dataArr = args[0];
-        var dataLen = dataArr.length;
-        while (dataLen--) this.addData(dataArr[dataLen]);
-      } else {
-        // add to store
-        var organisedEntry = this._organiseData(args[0], true);
-        if (organisedEntry) {
-          // if it's the first datapoint initialize the extremas with it
-          if (this._data.length === 0) this._min = this._max = organisedEntry.value;
-          this._coordinator.emit('renderpartial', {
-            min: this._min,
-            max: this._max,
-            data: [organisedEntry]
-          });
-        }
+    }
+    return {
+      min: this._min,
+      max: this._max,
+      data: unorganizedData
+    };
+  }
+  _onExtremaChange() {
+    this._coordinator.emit('extremachange', {
+      min: this._min,
+      max: this._max
+    });
+  }
+  addData(...args) {
+    if (args[0].length > 0) {
+      const dataArr = args[0];
+      let dataLen = dataArr.length;
+      while (dataLen--) this.addData(dataArr[dataLen]);
+    } else {
+      // add to store
+      const organisedEntry = this._organiseData(args[0], true);
+      if (organisedEntry) {
+        // if it's the first datapoint initialize the extremas with it
+        if (this._data.length === 0) this._min = this._max = organisedEntry.value;
+        this._coordinator.emit('renderpartial', {
+          min: this._min,
+          max: this._max,
+          data: [organisedEntry]
+        });
       }
-      return this;
     }
-  }, {
-    key: "setData",
-    value: function setData(data) {
-      var dataPoints = data.data;
-      var pointsLen = dataPoints.length;
+    return this;
+  }
+  setData(data) {
+    const dataPoints = data.data;
+    const pointsLen = dataPoints.length;
 
-      // reset data arrays
-      this._data = [];
-      this._radi = [];
-      for (var i = 0; i < pointsLen; i++) this._organiseData(dataPoints[i], false);
-      this._max = data.max;
-      this._min = data.min || 0;
-      this._onExtremaChange();
-      this._coordinator.emit('renderall', this.getInternalData());
-      return this;
-    }
-  }, {
-    key: "removeData",
-    value: function removeData() {
-      // TODO: implement
-    }
-  }, {
-    key: "setDataMax",
-    value: function setDataMax(max) {
-      this._max = max;
-      this._onExtremaChange();
-      this._coordinator.emit('renderall', this.getInternalData());
-      return this;
-    }
-  }, {
-    key: "setDataMin",
-    value: function setDataMin(min) {
-      this._min = min;
-      this._onExtremaChange();
-      this._coordinator.emit('renderall', this.getInternalData());
-      return this;
-    }
-  }, {
-    key: "setCoordinator",
-    value: function setCoordinator(coordinator) {
-      this._coordinator = coordinator;
-    }
-  }, {
-    key: "getInternalData",
-    value: function getInternalData() {
-      return {
-        max: this._max,
-        min: this._min,
-        data: this._data,
-        radi: this._radi
-      };
-    }
-  }, {
-    key: "getData",
-    value: function getData() {
-      return this._unOrganizeData();
-    }
-  }, {
-    key: "getValueAt",
-    value: function getValueAt(point) {
-      var _renderer;
-      var shadowCtx = (_renderer = this._renderer) === null || _renderer === void 0 ? void 0 : _renderer.shadowCtx;
-      if (!shadowCtx) return null;
-      var img = shadowCtx.getImageData(point.x, point.y, 1, 1);
-      var data = img.data[3];
-      var max = this._max;
-      var min = this._min;
-      var value = Math.abs(max - min) * (data / 255) >> 0;
-      return value;
-    }
-  }]);
-  return Store;
-}();
-var Canvas2dRenderer = /*#__PURE__*/function () {
-  function Canvas2dRenderer(config) {
+    // reset data arrays
+    this._data = [];
+    this._radi = [];
+    for (let i = 0; i < pointsLen; i++) this._organiseData(dataPoints[i], false);
+    this._max = data.max;
+    this._min = data.min || 0;
+    this._onExtremaChange();
+    this._coordinator.emit('renderall', this.getInternalData());
+    return this;
+  }
+  removeData() {
+    // TODO: implement
+  }
+  setDataMax(max) {
+    this._max = max;
+    this._onExtremaChange();
+    this._coordinator.emit('renderall', this.getInternalData());
+    return this;
+  }
+  setDataMin(min) {
+    this._min = min;
+    this._onExtremaChange();
+    this._coordinator.emit('renderall', this.getInternalData());
+    return this;
+  }
+  setCoordinator(coordinator) {
+    this._coordinator = coordinator;
+  }
+  getInternalData() {
+    return {
+      max: this._max,
+      min: this._min,
+      data: this._data,
+      radi: this._radi
+    };
+  }
+  getData() {
+    return this._unOrganizeData();
+  }
+  getValueAt(point) {
+    var _renderer;
+    const shadowCtx = (_renderer = this._renderer) === null || _renderer === void 0 ? void 0 : _renderer.shadowCtx;
+    if (!shadowCtx) return null;
+    const img = shadowCtx.getImageData(point.x, point.y, 1, 1);
+    const data = img.data[3];
+    const max = this._max;
+    const min = this._min;
+    const value = Math.abs(max - min) * (data / 255) >> 0;
+    return value;
+  }
+}
+class Canvas2dRenderer {
+  constructor(config) {
     var _width, _height;
-    _classCallCheck(this, Canvas2dRenderer);
     _defineProperty(this, "shadowCanvas", void 0);
     _defineProperty(this, "canvas", void 0);
     _defineProperty(this, "_renderBoundaries", void 0);
@@ -234,11 +193,11 @@ var Canvas2dRenderer = /*#__PURE__*/function () {
     _defineProperty(this, "_useGradientOpacity", void 0);
     _defineProperty(this, "_min", void 0);
     _defineProperty(this, "_max", void 0);
-    var container = config.container;
+    const container = config.container;
     this.shadowCanvas = document.createElement('canvas');
     this.canvas = config.canvas || document.createElement('canvas');
     this._renderBoundaries = [10000, 10000, 0, 0];
-    var computed = getComputedStyle(config.container) || {};
+    const computed = getComputedStyle(config.container) || {};
     this.canvas.className = 'heatmap-canvas';
     this._width = this.canvas.width = this.shadowCanvas.width = config.width || +((_width = computed.width) === null || _width === void 0 ? void 0 : _width.replace(/px/, '')) || 0;
     this._height = this.canvas.height = this.shadowCanvas.height = config.height || +((_height = computed.height) === null || _height === void 0 ? void 0 : _height.replace(/px/, '')) || 0;
@@ -251,264 +210,226 @@ var Canvas2dRenderer = /*#__PURE__*/function () {
     this._templates = {};
     this._setStyles(config);
   }
-  _createClass(Canvas2dRenderer, [{
-    key: "_getColorPalette",
-    value: function _getColorPalette(config) {
-      var _config$gradient;
-      var gradientConfig = (_config$gradient = config.gradient) !== null && _config$gradient !== void 0 ? _config$gradient : config.defaultGradient;
-      var paletteCanvas = document.createElement('canvas');
-      var paletteCtx = paletteCanvas.getContext('2d');
-      paletteCanvas.width = 256;
-      paletteCanvas.height = 1;
-      var gradient = paletteCtx.createLinearGradient(0, 0, 256, 1);
-      for (var _key2 in gradientConfig) gradient.addColorStop(+_key2, gradientConfig[_key2]);
-      paletteCtx.fillStyle = gradient;
-      paletteCtx.fillRect(0, 0, 256, 1);
-      return paletteCtx.getImageData(0, 0, 256, 1).data;
-    }
-  }, {
-    key: "_getPointTemplate",
-    value: function _getPointTemplate(radius, blurFactor) {
-      var tplCanvas = document.createElement('canvas');
-      var tplCtx = tplCanvas.getContext('2d');
-      var x = radius;
-      var y = radius;
-      tplCanvas.width = tplCanvas.height = radius * 2;
-      if (blurFactor === 1) {
-        tplCtx.beginPath();
-        tplCtx.arc(x, y, radius, 0, 2 * Math.PI, false);
-        tplCtx.fillStyle = 'rgba(0,0,0,1)';
-        tplCtx.fill();
-      } else {
-        var gradient = tplCtx.createRadialGradient(x, y, radius * blurFactor, x, y, radius);
-        gradient.addColorStop(0, 'rgba(0,0,0,1)');
-        gradient.addColorStop(1, 'rgba(0,0,0,0)');
-        tplCtx.fillStyle = gradient;
-        tplCtx.fillRect(0, 0, 2 * radius, 2 * radius);
-      }
-      return tplCanvas;
-    }
-  }, {
-    key: "_prepareData",
-    value: function _prepareData(data) {
-      var renderData = [];
-      var min = data.min;
-      var max = data.max;
-      var radi = data.radi;
-      var data2 = data.data;
-      var xValues = Object.keys(data2);
-      var xValuesLen = xValues.length;
-      while (xValuesLen--) {
-        var xValue = xValues[xValuesLen];
-        var yValues = Object.keys(data2[xValue]);
-        var yValuesLen = yValues.length;
-        while (yValuesLen--) {
-          var yValue = yValues[yValuesLen];
-          var value = data2[xValue][yValue];
-          var radius = radi[xValue][yValue];
-          renderData.push({
-            x: xValue,
-            y: yValue,
-            value: value,
-            radius: radius
-          });
-        }
-      }
-      return {
-        min: min,
-        max: max,
-        data: renderData
-      };
-    }
-  }, {
-    key: "renderPartial",
-    value: function renderPartial(data) {
-      if (data.data.length > 0) {
-        this._drawAlpha(data);
-        this._colorize();
-      }
+  _getColorPalette(config) {
+    var _config$gradient;
+    const gradientConfig = (_config$gradient = config.gradient) !== null && _config$gradient !== void 0 ? _config$gradient : config.defaultGradient;
+    const paletteCanvas = document.createElement('canvas');
+    const paletteCtx = paletteCanvas.getContext('2d');
+    paletteCanvas.width = 256;
+    paletteCanvas.height = 1;
+    const gradient = paletteCtx.createLinearGradient(0, 0, 256, 1);
+    for (const key in gradientConfig) gradient.addColorStop(+key, gradientConfig[key]);
+    paletteCtx.fillStyle = gradient;
+    paletteCtx.fillRect(0, 0, 256, 1);
+    return paletteCtx.getImageData(0, 0, 256, 1).data;
+  }
+  _getPointTemplate(radius, blurFactor) {
+    const tplCanvas = document.createElement('canvas');
+    const tplCtx = tplCanvas.getContext('2d');
+    const x = radius;
+    const y = radius;
+    tplCanvas.width = tplCanvas.height = radius * 2;
+    if (blurFactor === 1) {
+      tplCtx.beginPath();
+      tplCtx.arc(x, y, radius, 0, 2 * Math.PI, false);
+      tplCtx.fillStyle = 'rgba(0,0,0,1)';
+      tplCtx.fill();
+    } else {
+      const gradient = tplCtx.createRadialGradient(x, y, radius * blurFactor, x, y, radius);
+      gradient.addColorStop(0, 'rgba(0,0,0,1)');
+      gradient.addColorStop(1, 'rgba(0,0,0,0)');
+      tplCtx.fillStyle = gradient;
+      tplCtx.fillRect(0, 0, 2 * radius, 2 * radius);
     }
-  }, {
-    key: "renderAll",
-    value: function renderAll(data) {
-      this._clear();
-      if (data.data.length > 0) {
-        this._drawAlpha(this._prepareData(data));
-        this._colorize();
+    return tplCanvas;
+  }
+  _prepareData(data) {
+    const renderData = [];
+    const min = data.min;
+    const max = data.max;
+    const radi = data.radi;
+    const data2 = data.data;
+    const xValues = Object.keys(data2);
+    let xValuesLen = xValues.length;
+    while (xValuesLen--) {
+      const xValue = xValues[xValuesLen];
+      const yValues = Object.keys(data2[xValue]);
+      let yValuesLen = yValues.length;
+      while (yValuesLen--) {
+        const yValue = yValues[yValuesLen];
+        const value = data2[xValue][yValue];
+        const radius = radi[xValue][yValue];
+        renderData.push({
+          x: xValue,
+          y: yValue,
+          value,
+          radius
+        });
       }
     }
-  }, {
-    key: "_updateGradient",
-    value: function _updateGradient(config) {
-      this._palette = this._getColorPalette(config);
-    }
-  }, {
-    key: "updateConfig",
-    value: function updateConfig(config) {
-      if (config.gradient) this._updateGradient(config);
-      this._setStyles(config);
-    }
-  }, {
-    key: "setDimensions",
-    value: function setDimensions(width, height) {
-      this._width = width;
-      this._height = height;
-      this.canvas.width = this.shadowCanvas.width = width;
-      this.canvas.height = this.shadowCanvas.height = height;
-    }
-  }, {
-    key: "_clear",
-    value: function _clear() {
-      this.shadowCtx.clearRect(0, 0, this._width, this._height);
-      this.ctx.clearRect(0, 0, this._width, this._height);
+    return {
+      min,
+      max,
+      data: renderData
+    };
+  }
+  renderPartial(data) {
+    if (data.data.length > 0) {
+      this._drawAlpha(data);
+      this._colorize();
     }
-  }, {
-    key: "_setStyles",
-    value: function _setStyles(config) {
-      this._blur = config.blur === 0 ? 0 : config.blur || config.defaultBlur;
-      if (config.backgroundColor) this.canvas.style.backgroundColor = config.backgroundColor;
-      this._width = this.canvas.width = this.shadowCanvas.width = config.width || this._width;
-      this._height = this.canvas.height = this.shadowCanvas.height = config.height || this._height;
-      this._opacity = (config.opacity || 0) * 255;
-      this._maxOpacity = (config.maxOpacity || config.defaultMaxOpacity) * 255;
-      this._minOpacity = (config.minOpacity || config.defaultMinOpacity) * 255;
-      this._useGradientOpacity = !!config.useGradientOpacity;
+  }
+  renderAll(data) {
+    this._clear();
+    if (data.data.length > 0) {
+      this._drawAlpha(this._prepareData(data));
+      this._colorize();
     }
-  }, {
-    key: "_drawAlpha",
-    value: function _drawAlpha(data) {
-      this._min = data.min;
-      this._max = data.max;
-      var data2 = data.data || [];
-      var dataLen = data2.length;
-      // on a point basis?
-      var blur = 1 - this._blur;
-      while (dataLen--) {
-        var point = data2[dataLen];
-        var x = point.x;
-        var y = point.y;
-        var radius = point.radius;
-        // if value is bigger than max
-        // use max as value
-        var value = Math.min(point.value, this._max);
-        var rectX = x - radius;
-        var rectY = y - radius;
-        var shadowCtx = this.shadowCtx;
-        var tpl = void 0;
-        if (!this._templates[radius]) this._templates[radius] = tpl = this._getPointTemplate(radius, blur);else tpl = this._templates[radius];
+  }
+  _updateGradient(config) {
+    this._palette = this._getColorPalette(config);
+  }
+  updateConfig(config) {
+    if (config.gradient) this._updateGradient(config);
+    this._setStyles(config);
+  }
+  setDimensions(width, height) {
+    this._width = width;
+    this._height = height;
+    this.canvas.width = this.shadowCanvas.width = width;
+    this.canvas.height = this.shadowCanvas.height = height;
+  }
+  _clear() {
+    this.shadowCtx.clearRect(0, 0, this._width, this._height);
+    this.ctx.clearRect(0, 0, this._width, this._height);
+  }
+  _setStyles(config) {
+    this._blur = config.blur === 0 ? 0 : config.blur || config.defaultBlur;
+    if (config.backgroundColor) this.canvas.style.backgroundColor = config.backgroundColor;
+    this._width = this.canvas.width = this.shadowCanvas.width = config.width || this._width;
+    this._height = this.canvas.height = this.shadowCanvas.height = config.height || this._height;
+    this._opacity = (config.opacity || 0) * 255;
+    this._maxOpacity = (config.maxOpacity || config.defaultMaxOpacity) * 255;
+    this._minOpacity = (config.minOpacity || config.defaultMinOpacity) * 255;
+    this._useGradientOpacity = !!config.useGradientOpacity;
+  }
+  _drawAlpha(data) {
+    this._min = data.min;
+    this._max = data.max;
+    const data2 = data.data || [];
+    let dataLen = data2.length;
+    // on a point basis?
+    const blur = 1 - this._blur;
+    while (dataLen--) {
+      const point = data2[dataLen];
+      const x = point.x;
+      const y = point.y;
+      const radius = point.radius;
+      // if value is bigger than max
+      // use max as value
+      const value = Math.min(point.value, this._max);
+      const rectX = x - radius;
+      const rectY = y - radius;
+      const shadowCtx = this.shadowCtx;
+      let tpl;
+      if (!this._templates[radius]) this._templates[radius] = tpl = this._getPointTemplate(radius, blur);else tpl = this._templates[radius];
 
-        // value from minimum / value range
-        // => [0, 1]
-        var templateAlpha = (value - this._min) / (this._max - this._min);
-        // this fixes #176: small values are not visible because globalAlpha < .01 cannot be read from imageData
-        shadowCtx.globalAlpha = templateAlpha < 0.01 ? 0.01 : templateAlpha;
-        shadowCtx.drawImage(tpl, rectX, rectY);
+      // value from minimum / value range
+      // => [0, 1]
+      const templateAlpha = (value - this._min) / (this._max - this._min);
+      // this fixes #176: small values are not visible because globalAlpha < .01 cannot be read from imageData
+      shadowCtx.globalAlpha = templateAlpha < 0.01 ? 0.01 : templateAlpha;
+      shadowCtx.drawImage(tpl, rectX, rectY);
 
-        // update renderBoundaries
-        if (rectX < this._renderBoundaries[0]) this._renderBoundaries[0] = rectX;
-        if (rectY < this._renderBoundaries[1]) this._renderBoundaries[1] = rectY;
-        if (rectX + 2 * radius > this._renderBoundaries[2]) this._renderBoundaries[2] = rectX + 2 * radius;
-        if (rectY + 2 * radius > this._renderBoundaries[3]) this._renderBoundaries[3] = rectY + 2 * radius;
-      }
+      // update renderBoundaries
+      if (rectX < this._renderBoundaries[0]) this._renderBoundaries[0] = rectX;
+      if (rectY < this._renderBoundaries[1]) this._renderBoundaries[1] = rectY;
+      if (rectX + 2 * radius > this._renderBoundaries[2]) this._renderBoundaries[2] = rectX + 2 * radius;
+      if (rectY + 2 * radius > this._renderBoundaries[3]) this._renderBoundaries[3] = rectY + 2 * radius;
     }
-  }, {
-    key: "_colorize",
-    value: function _colorize() {
-      var x = this._renderBoundaries[0];
-      var y = this._renderBoundaries[1];
-      var width = this._renderBoundaries[2] - x;
-      var height = this._renderBoundaries[3] - y;
-      var maxWidth = this._width;
-      var maxHeight = this._height;
-      var opacity = this._opacity;
-      var maxOpacity = this._maxOpacity;
-      var minOpacity = this._minOpacity;
-      var useGradientOpacity = this._useGradientOpacity;
-      if (x < 0) x = 0;
-      if (y < 0) y = 0;
-      if (x + width > maxWidth) width = maxWidth - x;
-      if (y + height > maxHeight) height = maxHeight - y;
-      var img = this.shadowCtx.getImageData(x, y, width, height);
-      var imgData = img.data;
-      var len = imgData.length;
-      var palette = this._palette;
-      for (var i = 3; i < len; i += 4) {
-        var alpha = imgData[i];
-        var offset = alpha * 4;
-        if (!offset) continue;
-        var finalAlpha = void 0;
-        if (opacity > 0) {
-          finalAlpha = opacity;
+  }
+  _colorize() {
+    let x = this._renderBoundaries[0];
+    let y = this._renderBoundaries[1];
+    let width = this._renderBoundaries[2] - x;
+    let height = this._renderBoundaries[3] - y;
+    const maxWidth = this._width;
+    const maxHeight = this._height;
+    const opacity = this._opacity;
+    const maxOpacity = this._maxOpacity;
+    const minOpacity = this._minOpacity;
+    const useGradientOpacity = this._useGradientOpacity;
+    if (x < 0) x = 0;
+    if (y < 0) y = 0;
+    if (x + width > maxWidth) width = maxWidth - x;
+    if (y + height > maxHeight) height = maxHeight - y;
+    const img = this.shadowCtx.getImageData(x, y, width, height);
+    const imgData = img.data;
+    const len = imgData.length;
+    const palette = this._palette;
+    for (let i = 3; i < len; i += 4) {
+      const alpha = imgData[i];
+      const offset = alpha * 4;
+      if (!offset) continue;
+      let finalAlpha;
+      if (opacity > 0) {
+        finalAlpha = opacity;
+      } else {
+        if (alpha < maxOpacity) {
+          if (alpha < minOpacity) finalAlpha = minOpacity;else finalAlpha = alpha;
         } else {
-          if (alpha < maxOpacity) {
-            if (alpha < minOpacity) finalAlpha = minOpacity;else finalAlpha = alpha;
-          } else {
-            finalAlpha = maxOpacity;
-          }
+          finalAlpha = maxOpacity;
         }
-        imgData[i - 3] = palette[offset];
-        imgData[i - 2] = palette[offset + 1];
-        imgData[i - 1] = palette[offset + 2];
-        imgData[i] = useGradientOpacity ? palette[offset + 3] : finalAlpha;
       }
-
-      // 创建新的ImageData对象
-      var newImg = new ImageData(imgData, width, height);
-      this.ctx.putImageData(newImg, x, y);
-      this._renderBoundaries = [1000, 1000, 0, 0];
-    }
-  }, {
-    key: "getValueAt",
-    value: function getValueAt(point) {
-      var shadowCtx = this.shadowCtx;
-      var img = shadowCtx.getImageData(point.x, point.y, 1, 1);
-      var data = img.data[3];
-      var max = this._max;
-      var min = this._min;
-      var value = Math.abs(max - min) * (data / 255) >> 0;
-      return value;
-    }
-  }, {
-    key: "getDataURL",
-    value: function getDataURL() {
-      return this.canvas.toDataURL();
+      imgData[i - 3] = palette[offset];
+      imgData[i - 2] = palette[offset + 1];
+      imgData[i - 1] = palette[offset + 2];
+      imgData[i] = useGradientOpacity ? palette[offset + 3] : finalAlpha;
     }
-  }]);
-  return Canvas2dRenderer;
-}();
-var Coordinator = /*#__PURE__*/function () {
-  function Coordinator() {
-    _classCallCheck(this, Coordinator);
+
+    // 创建新的ImageData对象
+    const newImg = new ImageData(imgData, width, height);
+    this.ctx.putImageData(newImg, x, y);
+    this._renderBoundaries = [1000, 1000, 0, 0];
+  }
+  getValueAt(point) {
+    const shadowCtx = this.shadowCtx;
+    const img = shadowCtx.getImageData(point.x, point.y, 1, 1);
+    const data = img.data[3];
+    const max = this._max;
+    const min = this._min;
+    const value = Math.abs(max - min) * (data / 255) >> 0;
+    return value;
+  }
+  getDataURL() {
+    return this.canvas.toDataURL();
+  }
+}
+class Coordinator {
+  constructor() {
     _defineProperty(this, "cStore", void 0);
     this.cStore = {};
   }
-  _createClass(Coordinator, [{
-    key: "on",
-    value: function on(evtName, callback, scope) {
-      var cStore = this.cStore;
-      if (!cStore[evtName]) cStore[evtName] = [];
-      cStore[evtName].push(function (data) {
-        return callback.call(scope, data);
-      });
-    }
-  }, {
-    key: "emit",
-    value: function emit(evtName, data) {
-      var cStore = this.cStore;
-      if (cStore[evtName]) {
-        var len = cStore[evtName].length;
-        for (var i = 0; i < len; i++) {
-          var callback = cStore[evtName][i];
-          callback(data);
-        }
+  on(evtName, callback, scope) {
+    const cStore = this.cStore;
+    if (!cStore[evtName]) cStore[evtName] = [];
+    cStore[evtName].push(data => {
+      return callback.call(scope, data);
+    });
+  }
+  emit(evtName, data) {
+    const cStore = this.cStore;
+    if (cStore[evtName]) {
+      const len = cStore[evtName].length;
+      for (let i = 0; i < len; i++) {
+        const callback = cStore[evtName][i];
+        callback(data);
       }
     }
-  }]);
-  return Coordinator;
-}();
-var Heatmap = /*#__PURE__*/function () {
-  function Heatmap(config) {
-    _classCallCheck(this, Heatmap);
+  }
+}
+class Heatmap {
+  constructor(config) {
     _defineProperty(this, "_config", void 0);
     _defineProperty(this, "_coordinator", void 0);
     _defineProperty(this, "_renderer", void 0);
@@ -516,16 +437,16 @@ var Heatmap = /*#__PURE__*/function () {
     this._config = _objectSpread(_objectSpread({}, HeatmapConfig), config);
     this._coordinator = new Coordinator();
     if (config.plugin) {
-      var pluginToLoad = config.plugin;
+      const pluginToLoad = config.plugin;
       if (!HeatmapConfig.plugins[pluginToLoad]) {
-        throw new Error("Plugin '".concat(pluginToLoad, "' not found. Maybe it was not registered."));
+        throw new Error(`Plugin '${pluginToLoad}' not found. Maybe it was not registered.`);
       } else {
-        var plugin = HeatmapConfig.plugins[pluginToLoad];
+        const plugin = HeatmapConfig.plugins[pluginToLoad];
         // set plugin renderer and store
-        var Renderer = plugin.renderer;
-        var _Store = plugin.store;
+        const Renderer = plugin.renderer;
+        const Store = plugin.store;
         this._renderer = new Renderer(config);
-        this._store = new _Store(config);
+        this._store = new Store(config);
       }
     } else {
       this._renderer = new Canvas2dRenderer(config);
@@ -533,107 +454,66 @@ var Heatmap = /*#__PURE__*/function () {
     }
     this._connect();
   }
-  _createClass(Heatmap, [{
-    key: "_connect",
-    value: function _connect() {
-      var _this = this;
-      var renderer = this._renderer;
-      var coordinator = this._coordinator;
-      var store = this._store;
-      coordinator.on('renderpartial', renderer.renderPartial, renderer);
-      coordinator.on('renderall', renderer.renderAll, renderer);
-      coordinator.on('extremachange', function (data) {
-        _this._config.onExtremaChange && _this._config.onExtremaChange({
-          min: data.min,
-          max: data.max,
-          gradient: _this._config.gradient || _this._config.defaultGradient
-        });
+  _connect() {
+    const renderer = this._renderer;
+    const coordinator = this._coordinator;
+    const store = this._store;
+    coordinator.on('renderpartial', renderer.renderPartial, renderer);
+    coordinator.on('renderall', renderer.renderAll, renderer);
+    coordinator.on('extremachange', data => {
+      this._config.onExtremaChange && this._config.onExtremaChange({
+        min: data.min,
+        max: data.max,
+        gradient: this._config.gradient || this._config.defaultGradient
       });
-      store.setCoordinator(coordinator);
-    }
-  }, {
-    key: "addData",
-    value: function addData() {
-      var _this$_store;
-      for (var _len2 = arguments.length, args = new Array(_len2), _key3 = 0; _key3 < _len2; _key3++) {
-        args[_key3] = arguments[_key3];
-      }
-      if (args.length === 1) this._store.addData(args[0]);else (_this$_store = this._store).addData.apply(_this$_store, _toConsumableArray(args));
-      return this;
-    }
-  }, {
-    key: "removeData",
-    value: function removeData() {
-      if (this._store.removeData) this._store.removeData();
-      return this;
-    }
-  }, {
-    key: "setData",
-    value: function setData() {
-      var _this$_store2;
-      for (var _len3 = arguments.length, args = new Array(_len3), _key4 = 0; _key4 < _len3; _key4++) {
-        args[_key4] = arguments[_key4];
-      }
-      if (args.length === 1) this._store.setData(args[0]);else (_this$_store2 = this._store).setData.apply(_this$_store2, _toConsumableArray(args));
-      return this;
-    }
-  }, {
-    key: "setDataMax",
-    value: function setDataMax() {
-      var _this$_store3;
-      for (var _len4 = arguments.length, args = new Array(_len4), _key5 = 0; _key5 < _len4; _key5++) {
-        args[_key5] = arguments[_key5];
-      }
-      if (args.length === 1) this._store.setDataMax(args[0]);else (_this$_store3 = this._store).setDataMax.apply(_this$_store3, _toConsumableArray(args));
-      return this;
-    }
-  }, {
-    key: "setDataMin",
-    value: function setDataMin() {
-      var _this$_store4;
-      for (var _len5 = arguments.length, args = new Array(_len5), _key6 = 0; _key6 < _len5; _key6++) {
-        args[_key6] = arguments[_key6];
-      }
-      if (args.length === 1) this._store.setDataMin(args[0]);else (_this$_store4 = this._store).setDataMin.apply(_this$_store4, _toConsumableArray(args));
-      return this;
-    }
-  }, {
-    key: "configure",
-    value: function configure(config) {
-      this._config = _objectSpread(_objectSpread({}, this._config), config);
-      this._renderer.updateConfig(this._config);
-      this._coordinator.emit('renderall', this._store.getInternalData());
-      return this;
-    }
-  }, {
-    key: "repaint",
-    value: function repaint() {
-      this._coordinator.emit('renderall', this._store.getInternalData());
-      return this;
-    }
-  }, {
-    key: "getData",
-    value: function getData() {
-      return this._store.getData();
-    }
-  }, {
-    key: "getDataURL",
-    value: function getDataURL() {
-      return this._renderer.getDataURL();
-    }
-  }, {
-    key: "getValueAt",
-    value: function getValueAt(point) {
-      if (this._store.getValueAt) return this._store.getValueAt(point);else if (this._renderer.getValueAt) return this._renderer.getValueAt(point);else return null;
-    }
-  }]);
-  return Heatmap;
-}();
+    });
+    store.setCoordinator(coordinator);
+  }
+  addData(...args) {
+    if (args.length === 1) this._store.addData(args[0]);else this._store.addData(...args);
+    return this;
+  }
+  removeData(...args) {
+    if (this._store.removeData) this._store.removeData();
+    return this;
+  }
+  setData(...args) {
+    if (args.length === 1) this._store.setData(args[0]);else this._store.setData(...args);
+    return this;
+  }
+  setDataMax(...args) {
+    if (args.length === 1) this._store.setDataMax(args[0]);else this._store.setDataMax(...args);
+    return this;
+  }
+  setDataMin(...args) {
+    if (args.length === 1) this._store.setDataMin(args[0]);else this._store.setDataMin(...args);
+    return this;
+  }
+  configure(config) {
+    this._config = _objectSpread(_objectSpread({}, this._config), config);
+    this._renderer.updateConfig(this._config);
+    this._coordinator.emit('renderall', this._store.getInternalData());
+    return this;
+  }
+  repaint() {
+    this._coordinator.emit('renderall', this._store.getInternalData());
+    return this;
+  }
+  getData() {
+    return this._store.getData();
+  }
+  getDataURL() {
+    return this._renderer.getDataURL();
+  }
+  getValueAt(point) {
+    if (this._store.getValueAt) return this._store.getValueAt(point);else if (this._renderer.getValueAt) return this._renderer.getValueAt(point);else return null;
+  }
+}
 export default {
-  create: function create(config) {
+  create(config) {
     return new Heatmap(config);
   },
-  register: function register(pluginKey, plugin) {
+  register(pluginKey, plugin) {
     HeatmapConfig.plugins[pluginKey] = plugin;
   }
 };