@anov/3d-ability 0.0.91 → 0.0.93

package/dist/business/HeatMap/core.js

@@ -0,0 +1,640 @@
+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 = {
+  defaultRadius: 40,
+  defaultRenderer: 'canvas2d',
+  defaultGradient: {
+    0.25: 'rgb(0,0,255)',
+    0.55: 'rgb(0,255,0)',
+    0.85: 'yellow',
+    1.0: 'rgb(255,0,0)'
+  },
+  defaultMaxOpacity: 1,
+  defaultMinOpacity: 0,
+  defaultBlur: 0.85,
+  defaultXField: 'x',
+  defaultYField: 'y',
+  defaultValueField: 'value',
+  plugins: {}
+};
+var Store = /*#__PURE__*/function () {
+  function Store(config) {
+    _classCallCheck(this, Store);
+    _defineProperty(this, "_coordinator", {});
+    _defineProperty(this, "_data", []);
+    _defineProperty(this, "_radi", []);
+    _defineProperty(this, "_min", 10);
+    _defineProperty(this, "_max", 1);
+    _defineProperty(this, "_xField", void 0);
+    _defineProperty(this, "_yField", void 0);
+    _defineProperty(this, "_valueField", void 0);
+    _defineProperty(this, "_cfgRadius", void 0);
+    this._xField = config.xField || config.defaultXField;
+    this._yField = config.yField || config.defaultYField;
+    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]
+          });
+        }
+      }
+      return {
+        min: this._min,
+        max: this._max,
+        data: unorganizedData
+      };
+    }
+  }, {
+    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];
+      }
+      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;
+    }
+  }, {
+    key: "setData",
+    value: function setData(data) {
+      var dataPoints = data.data;
+      var 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) {
+    var _width, _height;
+    _classCallCheck(this, Canvas2dRenderer);
+    _defineProperty(this, "shadowCanvas", void 0);
+    _defineProperty(this, "canvas", void 0);
+    _defineProperty(this, "_renderBoundaries", void 0);
+    _defineProperty(this, "_width", void 0);
+    _defineProperty(this, "_height", void 0);
+    _defineProperty(this, "shadowCtx", void 0);
+    _defineProperty(this, "ctx", void 0);
+    _defineProperty(this, "_palette", void 0);
+    _defineProperty(this, "_templates", void 0);
+    _defineProperty(this, "_blur", void 0);
+    _defineProperty(this, "_opacity", void 0);
+    _defineProperty(this, "_maxOpacity", void 0);
+    _defineProperty(this, "_minOpacity", void 0);
+    _defineProperty(this, "_useGradientOpacity", void 0);
+    _defineProperty(this, "_min", void 0);
+    _defineProperty(this, "_max", void 0);
+    var 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) || {};
+    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;
+    this.shadowCtx = this.shadowCanvas.getContext('2d');
+    this.ctx = this.canvas.getContext('2d');
+    this.canvas.style.cssText = this.shadowCanvas.style.cssText = 'position:absolute;left:0;top:0;';
+    container.style.position = 'relative';
+    container.appendChild(this.canvas);
+    this._palette = this._getColorPalette(config);
+    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();
+      }
+    }
+  }, {
+    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]
+        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;
+      }
+    }
+  }, {
+    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 {
+          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;
+      }
+
+      // 创建新的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 = {};
+  }
+  _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);
+        }
+      }
+    }
+  }]);
+  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);
+    _defineProperty(this, "_store", void 0);
+    this._config = _objectSpread(_objectSpread({}, HeatmapConfig), config);
+    this._coordinator = new Coordinator();
+    if (config.plugin) {
+      var pluginToLoad = config.plugin;
+      if (!HeatmapConfig.plugins[pluginToLoad]) {
+        throw new Error("Plugin '".concat(pluginToLoad, "' not found. Maybe it was not registered."));
+      } else {
+        var plugin = HeatmapConfig.plugins[pluginToLoad];
+        // set plugin renderer and store
+        var Renderer = plugin.renderer;
+        var _Store = plugin.store;
+        this._renderer = new Renderer(config);
+        this._store = new _Store(config);
+      }
+    } else {
+      this._renderer = new Canvas2dRenderer(config);
+      this._store = new Store(config);
+    }
+    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
+        });
+      });
+      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 var heatmapFactory = {
+  create: function create(config) {
+    return new Heatmap(config);
+  },
+  register: function register(pluginKey, plugin) {
+    HeatmapConfig.plugins[pluginKey] = plugin;
+  }
+};
+//# sourceMappingURL=core.js.map