@anov/3d-ability 0.0.142 → 0.0.144

package/dist/business/HeatMap/core.js

@@ -1,9 +1,19 @@
+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); }
-const 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); }
+var HeatmapConfig = {
   defaultRadius: 40,
   defaultRenderer: 'canvas2d',
   defaultGradient: {
@@ -20,8 +30,9 @@ const HeatmapConfig = {
   defaultValueField: 'value',
   plugins: {}
 };
-class Store {
-  constructor(config) {
+var Store = /*#__PURE__*/function () {
+  function Store(config) {
+    _classCallCheck(this, Store);
     _defineProperty(this, "_coordinator", {});
     _defineProperty(this, "_data", []);
     _defineProperty(this, "_radi", []);
@@ -36,147 +47,177 @@ class Store {
     this._valueField = config.valueField || config.defaultValueField;
     if (config.radius) this._cfgRadius = config.radius;
   }
-  _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 {
+  _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]
+          });
+        }
+      }
       return {
-        x,
-        y,
-        value,
-        radius,
-        min,
-        max
+        min: this._min,
+        max: this._max,
+        data: unorganizedData
       };
     }
-  }
-  _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]
-        });
-      }
+  }, {
+    key: "_onExtremaChange",
+    value: function _onExtremaChange() {
+      this._coordinator.emit('extremachange', {
+        min: this._min,
+        max: this._max
+      });
     }
-    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]
-        });
+  }, {
+    key: "addData",
+    value: function addData() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      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 this;
     }
-    return this;
-  }
-  setData(data) {
-    const dataPoints = data.data;
-    const pointsLen = dataPoints.length;
+  }, {
+    key: "setData",
+    value: function setData(data) {
+      var dataPoints = data.data;
+      var pointsLen = dataPoints.length;
 
-    // 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) {
+      // 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) {
     var _width, _height;
+    _classCallCheck(this, Canvas2dRenderer);
     _defineProperty(this, "shadowCanvas", void 0);
     _defineProperty(this, "canvas", void 0);
     _defineProperty(this, "_renderBoundaries", void 0);
@@ -193,11 +234,11 @@ class Canvas2dRenderer {
     _defineProperty(this, "_useGradientOpacity", void 0);
     _defineProperty(this, "_min", void 0);
     _defineProperty(this, "_max", void 0);
-    const container = config.container;
+    var container = config.container;
     this.shadowCanvas = document.createElement('canvas');
     this.canvas = config.canvas || document.createElement('canvas');
     this._renderBoundaries = [10000, 10000, 0, 0];
-    const computed = getComputedStyle(config.container) || {};
+    var 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;
@@ -210,226 +251,264 @@ class Canvas2dRenderer {
     this._templates = {};
     this._setStyles(config);
   }
-  _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);
+  _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;
     }
-    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: "_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;
     }
-    return {
-      min,
-      max,
-      data: renderData
-    };
-  }
-  renderPartial(data) {
-    if (data.data.length > 0) {
-      this._drawAlpha(data);
-      this._colorize();
+  }, {
+    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
+      };
     }
-  }
-  renderAll(data) {
-    this._clear();
-    if (data.data.length > 0) {
-      this._drawAlpha(this._prepareData(data));
-      this._colorize();
+  }, {
+    key: "renderPartial",
+    value: function renderPartial(data) {
+      if (data.data.length > 0) {
+        this._drawAlpha(data);
+        this._colorize();
+      }
     }
-  }
-  _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];
+  }, {
+    key: "renderAll",
+    value: function renderAll(data) {
+      this._clear();
+      if (data.data.length > 0) {
+        this._drawAlpha(this._prepareData(data));
+        this._colorize();
+      }
+    }
+  }, {
+    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);
+    }
+  }, {
+    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;
+    }
+  }, {
+    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];
 
-      // 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);
+        // 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);
 
-      // 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;
+      }
     }
-  }
-  _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;
+  }, {
+    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;
         } else {
-          finalAlpha = maxOpacity;
+          if (alpha < maxOpacity) {
+            if (alpha < minOpacity) finalAlpha = minOpacity;else finalAlpha = alpha;
+          } else {
+            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;
       }
-      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对象
-    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() {
+      // 创建新的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();
+    }
+  }]);
+  return Canvas2dRenderer;
+}();
+var Coordinator = /*#__PURE__*/function () {
+  function Coordinator() {
+    _classCallCheck(this, Coordinator);
     _defineProperty(this, "cStore", void 0);
     this.cStore = {};
   }
-  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);
+  _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);
+        }
       }
     }
-  }
-}
-class Heatmap {
-  constructor(config) {
+  }]);
+  return Coordinator;
+}();
+var Heatmap = /*#__PURE__*/function () {
+  function Heatmap(config) {
+    _classCallCheck(this, Heatmap);
     _defineProperty(this, "_config", void 0);
     _defineProperty(this, "_coordinator", void 0);
     _defineProperty(this, "_renderer", void 0);
@@ -437,16 +516,16 @@ class Heatmap {
     this._config = _objectSpread(_objectSpread({}, HeatmapConfig), config);
     this._coordinator = new Coordinator();
     if (config.plugin) {
-      const pluginToLoad = config.plugin;
+      var pluginToLoad = config.plugin;
       if (!HeatmapConfig.plugins[pluginToLoad]) {
-        throw new Error(`Plugin '${pluginToLoad}' not found. Maybe it was not registered.`);
+        throw new Error("Plugin '".concat(pluginToLoad, "' not found. Maybe it was not registered."));
       } else {
-        const plugin = HeatmapConfig.plugins[pluginToLoad];
+        var plugin = HeatmapConfig.plugins[pluginToLoad];
         // set plugin renderer and store
-        const Renderer = plugin.renderer;
-        const Store = plugin.store;
+        var Renderer = plugin.renderer;
+        var _Store = plugin.store;
         this._renderer = new Renderer(config);
-        this._store = new Store(config);
+        this._store = new _Store(config);
       }
     } else {
       this._renderer = new Canvas2dRenderer(config);
@@ -454,66 +533,107 @@ class Heatmap {
     }
     this._connect();
   }
-  _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
+  _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
+        });
       });
-    });
-    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;
-  }
-}
+      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;
+}();
 export default {
-  create(config) {
+  create: function create(config) {
     return new Heatmap(config);
   },
-  register(pluginKey, plugin) {
+  register: function register(pluginKey, plugin) {
     HeatmapConfig.plugins[pluginKey] = plugin;
   }
 };