@kepler.gl/deckgl-layers 3.3.0-alpha.4 → 3.3.0-alpha.6

package/dist/cjs/layer-utils/cpu-aggregator.js

@@ -0,0 +1,798 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultElevationDimension = exports.defaultDimensions = exports.defaultColorDimension = exports.defaultAggregation = exports["default"] = exports.DECK_AGGREGATION_MAP = void 0;
+exports.getAggregatedData = getAggregatedData;
+exports.getDimensionScale = getDimensionScale;
+exports.getDimensionSortedBins = getDimensionSortedBins;
+exports.getDimensionValueDomain = getDimensionValueDomain;
+exports.getGetValue = getGetValue;
+exports.getScaleFunctor = getScaleFunctor;
+exports.getValueFunc = getValueFunc;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _window = require("global/window");
+var _utils = require("@kepler.gl/utils");
+var _constants = require("@kepler.gl/constants");
+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) { (0, _defineProperty2["default"])(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 _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+/* eslint-disable guard-for-in */
+var AGGREGATION_OPERATION = {
+  SUM: 'SUM',
+  MEAN: 'MEAN',
+  MIN: 'MIN',
+  MAX: 'MAX',
+  COUNT: 'COUNT'
+};
+var MAX_32_BIT_FLOAT = 3.402823466e38;
+var defaultGetValue = function defaultGetValue(points) {
+  return points.length;
+};
+var defaultGetPoints = function defaultGetPoints(bin) {
+  return bin.points;
+};
+var defaultGetIndex = function defaultGetIndex(bin) {
+  return bin.index;
+};
+var ascending = function ascending(a, b) {
+  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+};
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function getQuantileDomain(data, valueAccessor) {
+  return data.map(valueAccessor).sort(ascending);
+}
+function getOrdinalDomain(data, valueAccessor) {
+  return (0, _toConsumableArray2["default"])(new Set(data.map(valueAccessor)));
+}
+var BinSorter = /*#__PURE__*/function () {
+  function BinSorter() {
+    var bins = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    (0, _classCallCheck2["default"])(this, BinSorter);
+    (0, _defineProperty2["default"])(this, "maxCount", void 0);
+    (0, _defineProperty2["default"])(this, "maxValue", void 0);
+    (0, _defineProperty2["default"])(this, "minValue", void 0);
+    (0, _defineProperty2["default"])(this, "totalCount", void 0);
+    (0, _defineProperty2["default"])(this, "aggregatedBins", void 0);
+    (0, _defineProperty2["default"])(this, "sortedBins", void 0);
+    (0, _defineProperty2["default"])(this, "binMap", void 0);
+    this.aggregatedBins = this._getAggregatedBins(bins, props);
+    this._updateMinMaxValues();
+    this.binMap = this._getBinMap();
+  }
+  return (0, _createClass2["default"])(BinSorter, [{
+    key: "_getAggregatedBins",
+    value: function _getAggregatedBins(bins, props) {
+      var _props$getValue = props.getValue,
+        getValue = _props$getValue === void 0 ? defaultGetValue : _props$getValue,
+        _props$getPoints = props.getPoints,
+        getPoints = _props$getPoints === void 0 ? defaultGetPoints : _props$getPoints,
+        _props$getIndex = props.getIndex,
+        getIndex = _props$getIndex === void 0 ? defaultGetIndex : _props$getIndex,
+        filterData = props.filterData;
+      var hasFilter = typeof filterData === 'function';
+      var aggregatedBins = [];
+      var index = 0;
+      for (var binIndex = 0; binIndex < bins.length; binIndex++) {
+        var bin = bins[binIndex];
+        var points = getPoints(bin);
+        var i = getIndex(bin);
+        var filteredPoints = hasFilter ? points.filter(filterData) : points;
+        bin.filteredPoints = hasFilter ? filteredPoints : null;
+        var value = filteredPoints.length ? getValue(filteredPoints) : null;
+        if (value !== null && value !== undefined) {
+          aggregatedBins[index] = {
+            i: Number.isFinite(i) ? i : binIndex,
+            value: value,
+            counts: filteredPoints.length
+          };
+          index++;
+        }
+      }
+      return aggregatedBins;
+    }
+  }, {
+    key: "_updateMinMaxValues",
+    value: function _updateMinMaxValues() {
+      var maxCount = 0;
+      var maxValue = -MAX_32_BIT_FLOAT;
+      var minValue = MAX_32_BIT_FLOAT;
+      var totalCount = 0;
+      var _iterator = _createForOfIteratorHelper(this.aggregatedBins),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var x = _step.value;
+          maxCount = maxCount > x.counts ? maxCount : x.counts;
+          maxValue = maxValue > x.value ? maxValue : x.value;
+          minValue = minValue < x.value ? minValue : x.value;
+          totalCount += x.counts;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      if (this.aggregatedBins.length === 0) {
+        maxValue = 0;
+        minValue = 0;
+      }
+      this.maxCount = maxCount;
+      this.maxValue = maxValue;
+      this.minValue = minValue;
+      this.totalCount = totalCount;
+    }
+  }, {
+    key: "_getBinMap",
+    value: function _getBinMap() {
+      var binMap = {};
+      var _iterator2 = _createForOfIteratorHelper(this.aggregatedBins),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var bin = _step2.value;
+          binMap[bin.i] = bin;
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return binMap;
+    }
+  }, {
+    key: "_percentileToIndex",
+    value: function _percentileToIndex(percentileRange) {
+      var len = this.sortedBins.length;
+      if (len < 2) return [0, 0];
+      var _percentileRange$map = percentileRange.map(function (n) {
+          return clamp(n, 0, 100);
+        }),
+        _percentileRange$map2 = (0, _slicedToArray2["default"])(_percentileRange$map, 2),
+        lower = _percentileRange$map2[0],
+        upper = _percentileRange$map2[1];
+      return [Math.ceil(lower / 100 * (len - 1)), Math.floor(upper / 100 * (len - 1))];
+    }
+  }, {
+    key: "getValueDomainByScale",
+    value: function getValueDomainByScale(scale) {
+      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [],
+        _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+        _ref2$ = _ref2[0],
+        lower = _ref2$ === void 0 ? 0 : _ref2$,
+        _ref2$2 = _ref2[1],
+        upper = _ref2$2 === void 0 ? 100 : _ref2$2;
+      if (!this.sortedBins) {
+        this.sortedBins = this.aggregatedBins.sort(function (a, b) {
+          return ascending(a.value, b.value);
+        });
+      }
+      if (!this.sortedBins.length) return [];
+      var indexEdge = this._percentileToIndex([lower, upper]);
+      return this._getScaleDomain(scale, indexEdge);
+    }
+  }, {
+    key: "_getScaleDomain",
+    value: function _getScaleDomain(scaleType, _ref3) {
+      var _ref4 = (0, _slicedToArray2["default"])(_ref3, 2),
+        lowerIdx = _ref4[0],
+        upperIdx = _ref4[1];
+      var bins = this.sortedBins;
+      switch (scaleType) {
+        case 'quantize':
+        case 'linear':
+          return [bins[lowerIdx].value, bins[upperIdx].value];
+        case 'quantile':
+          return getQuantileDomain(bins.slice(lowerIdx, upperIdx + 1), function (d) {
+            return d.value;
+          });
+        case 'ordinal':
+          return getOrdinalDomain(bins, function (d) {
+            return d.value;
+          });
+        default:
+          return [bins[lowerIdx].value, bins[upperIdx].value];
+      }
+    }
+  }, {
+    key: "getValueRange",
+    value: function getValueRange(percentileRange) {
+      if (!this.sortedBins) {
+        this.sortedBins = this.aggregatedBins.sort(function (a, b) {
+          return ascending(a.value, b.value);
+        });
+      }
+      if (!this.sortedBins.length) return [];
+      var lowerIdx = 0;
+      var upperIdx = this.sortedBins.length - 1;
+      if (Array.isArray(percentileRange)) {
+        var idxRange = this._percentileToIndex(percentileRange);
+        lowerIdx = idxRange[0];
+        upperIdx = idxRange[1];
+      }
+      return [this.sortedBins[lowerIdx].value, this.sortedBins[upperIdx].value];
+    }
+  }]);
+}();
+var DECK_AGGREGATION_MAP = exports.DECK_AGGREGATION_MAP = (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, AGGREGATION_OPERATION.SUM, _constants.AGGREGATION_TYPES.sum), AGGREGATION_OPERATION.MEAN, _constants.AGGREGATION_TYPES.average), AGGREGATION_OPERATION.MIN, _constants.AGGREGATION_TYPES.minimum), AGGREGATION_OPERATION.MAX, _constants.AGGREGATION_TYPES.maximum);
+function getValueFunc(aggregation, accessor) {
+  if (!aggregation || !AGGREGATION_OPERATION[aggregation.toUpperCase()]) {
+    _window.console.warn("Aggregation ".concat(aggregation, " is not supported"));
+  }
+  var op = AGGREGATION_OPERATION[aggregation.toUpperCase()] || AGGREGATION_OPERATION.SUM;
+  var keplerOp = DECK_AGGREGATION_MAP[op];
+  return function (pts) {
+    return (0, _utils.aggregate)(pts.map(accessor), keplerOp);
+  };
+}
+function getScaleFunctor(scaleType) {
+  if (!scaleType || !_constants.SCALE_FUNC[scaleType]) {
+    _window.console.warn("Scale ".concat(scaleType, " is not supported"));
+  }
+  return _constants.SCALE_FUNC[scaleType] || _constants.SCALE_FUNC.quantize;
+}
+function nop() {
+  return;
+}
+function getGetValue(step, props, dimensionUpdater) {
+  var key = dimensionUpdater.key;
+  var _step$triggers = step.triggers,
+    value = _step$triggers.value,
+    weight = _step$triggers.weight,
+    aggregation = _step$triggers.aggregation;
+  var getValue = props[value.prop];
+  if (getValue === null) {
+    // If `getValue` is not provided from props, build it with aggregation and weight.
+    getValue = getValueFunc(props[aggregation.prop], props[weight.prop]);
+  }
+  if (getValue) {
+    this._setDimensionState(key, {
+      getValue: getValue
+    });
+  }
+}
+function getDimensionSortedBins(step, props, dimensionUpdater) {
+  var key = dimensionUpdater.key;
+  var getValue = this.state.dimensions[key].getValue;
+  var sortedBins = new BinSorter(this.state.layerData.data || [], {
+    getValue: getValue,
+    filterData: props._filterData
+  });
+  this._setDimensionState(key, {
+    sortedBins: sortedBins
+  });
+}
+function getDimensionValueDomain(step, props, dimensionUpdater) {
+  var key = dimensionUpdater.key;
+  var _step$triggers2 = step.triggers,
+    lowerPercentile = _step$triggers2.lowerPercentile,
+    upperPercentile = _step$triggers2.upperPercentile,
+    scaleType = _step$triggers2.scaleType;
+  if (!this.state.dimensions[key].sortedBins) {
+    // the previous step should set sortedBins, if not, something went wrong
+    return;
+  }
+  var valueDomain =
+  // for log and sqrt scale, returns linear domain by default
+  // TODO: support other scale function domain in bin sorter
+  this.state.dimensions[key].sortedBins.getValueDomainByScale(props[scaleType.prop], [props[lowerPercentile.prop], props[upperPercentile.prop]]);
+  if (props.colorScaleType === 'custom' && props.colorMap) {
+    // for custom scale, return custom breaks as value domain directly
+    valueDomain = props.colorMap.reduce(function (prev, cur) {
+      return Number.isFinite(cur[0]) ? prev.concat(cur[0]) : prev;
+    }, []);
+  }
+  this._setDimensionState(key, {
+    valueDomain: valueDomain
+  });
+}
+function getDimensionScale(step, props, dimensionUpdater) {
+  var key = dimensionUpdater.key;
+  var _step$triggers3 = step.triggers,
+    domain = _step$triggers3.domain,
+    range = _step$triggers3.range,
+    scaleType = _step$triggers3.scaleType,
+    fixed = _step$triggers3.fixed;
+  var onSet = step.onSet;
+  if (!this.state.dimensions[key].valueDomain) {
+    // the previous step should set valueDomain, if not, something went wrong
+    return;
+  }
+  var dimensionRange = props[range.prop];
+  var dimensionDomain = props[domain.prop] || this.state.dimensions[key].valueDomain;
+  var dimensionFixed = Boolean(fixed && props[fixed.prop]);
+  var scaleFunctor = getScaleFunctor(scaleType && props[scaleType.prop])();
+  var scaleFunc = scaleFunctor.domain(dimensionDomain).range(dimensionFixed ? dimensionDomain : dimensionRange);
+  scaleFunc.scaleType = props.colorScaleType;
+  if ((0, _typeof2["default"])(onSet) === 'object' && typeof props[onSet.props] === 'function') {
+    var sortedBins = this.state.dimensions[key].sortedBins;
+    if (sortedBins) {
+      props[onSet.props]({
+        domain: scaleFunc.domain(),
+        aggregatedBins: sortedBins.binMap
+      });
+    }
+  }
+  this._setDimensionState(key, {
+    scaleFunc: scaleFunc
+  });
+}
+function normalizeResult() {
+  var result = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  // support previous hexagonAggregator API
+  if (result.hexagons) {
+    return Object.assign({
+      data: result.hexagons
+    }, result);
+  } else if (result.layerData) {
+    return Object.assign({
+      data: result.layerData
+    }, result);
+  }
+  return result;
+}
+function getAggregatedData(step, props, aggregation, aggregationParams) {
+  var aggr = step.triggers.aggregator;
+  var aggregator = props[aggr.prop];
+
+  // result should contain a data array and other props
+  // result = {data: [], ...other props}
+  var result = aggregator(props, aggregationParams);
+  this.setState({
+    layerData: normalizeResult(result)
+  });
+}
+var defaultAggregation = exports.defaultAggregation = {
+  key: 'position',
+  updateSteps: [{
+    key: 'aggregate',
+    triggers: {
+      cellSize: {
+        prop: 'cellSize'
+      },
+      position: {
+        prop: 'getPosition',
+        updateTrigger: 'getPosition'
+      },
+      aggregator: {
+        prop: 'gridAggregator'
+      }
+    },
+    updater: getAggregatedData
+  }]
+};
+function getSubLayerAccessor(dimensionState, dimension) {
+  return function (cell) {
+    var sortedBins = dimensionState.sortedBins,
+      scaleFunc = dimensionState.scaleFunc;
+    var bin = sortedBins.binMap[cell.index];
+    if (bin && bin.counts === 0) {
+      // no points left in bin after filtering
+      return dimension.nullValue;
+    }
+    var cv = bin && bin.value;
+    var domain = scaleFunc.domain();
+    var isValueInDomain = scaleFunc.scaleType === 'custom' ? cv >= sortedBins.minValue && cv <= sortedBins.maxValue : cv >= domain[0] && cv <= domain[domain.length - 1];
+
+    // if cell value is outside domain, set alpha to 0
+    return isValueInDomain ? scaleFunc(cv) : dimension.nullValue;
+  };
+}
+var defaultColorDimension = exports.defaultColorDimension = {
+  key: 'fillColor',
+  accessor: 'getFillColor',
+  getPickingInfo: function getPickingInfo(dimensionState, cell) {
+    if (!cell) {
+      return {};
+    }
+    var sortedBins = dimensionState.sortedBins;
+    var colorValue = sortedBins.binMap[cell.index] && sortedBins.binMap[cell.index].value;
+    return {
+      colorValue: colorValue
+    };
+  },
+  nullValue: [0, 0, 0, 0],
+  updateSteps: [{
+    key: 'getValue',
+    triggers: {
+      value: {
+        prop: 'getColorValue',
+        updateTrigger: 'getColorValue'
+      },
+      weight: {
+        prop: 'getColorWeight',
+        updateTrigger: 'getColorWeight'
+      },
+      aggregation: {
+        prop: 'colorAggregation'
+      }
+    },
+    updater: getGetValue
+  }, {
+    key: 'getBins',
+    triggers: {
+      _filterData: {
+        prop: '_filterData',
+        updateTrigger: '_filterData'
+      }
+    },
+    updater: getDimensionSortedBins
+  }, {
+    key: 'getDomain',
+    triggers: {
+      lowerPercentile: {
+        prop: 'lowerPercentile'
+      },
+      upperPercentile: {
+        prop: 'upperPercentile'
+      },
+      scaleType: {
+        prop: 'colorScaleType'
+      }
+    },
+    updater: getDimensionValueDomain
+  }, {
+    key: 'getScaleFunc',
+    triggers: {
+      domain: {
+        prop: 'colorDomain'
+      },
+      range: {
+        prop: 'colorRange'
+      },
+      scaleType: {
+        prop: 'colorScaleType'
+      }
+    },
+    onSet: {
+      props: 'onSetColorDomain'
+    },
+    updater: getDimensionScale
+  }],
+  getSubLayerAccessor: getSubLayerAccessor
+};
+var defaultElevationDimension = exports.defaultElevationDimension = {
+  key: 'elevation',
+  accessor: 'getElevation',
+  getPickingInfo: function getPickingInfo(dimensionState, cell) {
+    if (!cell) {
+      return {};
+    }
+    var sortedBins = dimensionState.sortedBins;
+    var elevationValue = sortedBins.binMap[cell.index] && sortedBins.binMap[cell.index].value;
+    return {
+      elevationValue: elevationValue
+    };
+  },
+  nullValue: -1,
+  updateSteps: [{
+    key: 'getValue',
+    triggers: {
+      value: {
+        prop: 'getElevationValue',
+        updateTrigger: 'getElevationValue'
+      },
+      weight: {
+        prop: 'getElevationWeight',
+        updateTrigger: 'getElevationWeight'
+      },
+      aggregation: {
+        prop: 'elevationAggregation'
+      }
+    },
+    updater: getGetValue
+  }, {
+    key: 'getBins',
+    triggers: {
+      _filterData: {
+        prop: '_filterData',
+        updateTrigger: '_filterData'
+      }
+    },
+    updater: getDimensionSortedBins
+  }, {
+    key: 'getDomain',
+    triggers: {
+      lowerPercentile: {
+        prop: 'elevationLowerPercentile'
+      },
+      upperPercentile: {
+        prop: 'elevationUpperPercentile'
+      },
+      scaleType: {
+        prop: 'elevationScaleType'
+      }
+    },
+    updater: getDimensionValueDomain
+  }, {
+    key: 'getScaleFunc',
+    triggers: {
+      fixed: {
+        prop: 'elevationFixed'
+      },
+      domain: {
+        prop: 'elevationDomain'
+      },
+      range: {
+        prop: 'elevationRange'
+      },
+      scaleType: {
+        prop: 'elevationScaleType'
+      }
+    },
+    onSet: {
+      props: 'onSetElevationDomain'
+    },
+    updater: getDimensionScale
+  }],
+  getSubLayerAccessor: getSubLayerAccessor
+};
+var _defaultDimensions = exports.defaultDimensions = [defaultColorDimension, defaultElevationDimension];
+var CPUAggregator = exports["default"] = /*#__PURE__*/function () {
+  function CPUAggregator() {
+    var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2["default"])(this, CPUAggregator);
+    (0, _defineProperty2["default"])(this, "state", void 0);
+    (0, _defineProperty2["default"])(this, "dimensionUpdaters", void 0);
+    (0, _defineProperty2["default"])(this, "aggregationUpdater", void 0);
+    this.state = _objectSpread({
+      layerData: {},
+      dimensions: {
+        // color: {
+        //   getValue: null,
+        //   domain: null,
+        //   sortedBins: null,
+        //   scaleFunc: nop
+        // },
+        // elevation: {
+        //   getValue: null,
+        //   domain: null,
+        //   sortedBins: null,
+        //   scaleFunc: nop
+        // }
+      }
+    }, opts.initialState);
+    this.dimensionUpdaters = {};
+    this.aggregationUpdater = opts.aggregation || defaultAggregation;
+    this._addDimension(opts.dimensions || _defaultDimensions);
+  }
+  return (0, _createClass2["default"])(CPUAggregator, [{
+    key: "updateAllDimensions",
+    value: function updateAllDimensions(props) {
+      var dimensionChanges = [];
+      // update all dimensions
+      for (var dim in this.dimensionUpdaters) {
+        var updaters = this._accumulateUpdaters(0, props, this.dimensionUpdaters[dim]);
+        dimensionChanges = dimensionChanges.concat(updaters);
+      }
+      dimensionChanges.forEach(function (f) {
+        return typeof f === 'function' && f();
+      });
+    }
+  }, {
+    key: "updateAggregation",
+    value: function updateAggregation(props, aggregationParams) {
+      var updaters = this._accumulateUpdaters(0, props, this.aggregationUpdater);
+      updaters.forEach(function (f) {
+        return typeof f === 'function' && f(aggregationParams);
+      });
+    }
+  }, {
+    key: "updateState",
+    value: function updateState(opts, aggregationParams) {
+      var oldProps = opts.oldProps,
+        props = opts.props,
+        changeFlags = opts.changeFlags;
+      var dimensionChanges = [];
+      if (changeFlags.dataChanged) {
+        // if data changed update everything
+        this.updateAggregation(props, aggregationParams);
+        this.updateAllDimensions(props);
+        return this.state;
+      }
+      var aggregationChanges = this._getAggregationChanges(oldProps, props, changeFlags);
+      if (aggregationChanges && aggregationChanges.length) {
+        // get aggregatedData
+        aggregationChanges.forEach(function (f) {
+          return typeof f === 'function' && f(aggregationParams);
+        });
+        this.updateAllDimensions(props);
+      } else {
+        // only update dimensions
+        dimensionChanges = this._getDimensionChanges(oldProps, props, changeFlags) || [];
+        dimensionChanges.forEach(function (f) {
+          return typeof f === 'function' && f();
+        });
+      }
+      return this.state;
+    }
+
+    // Update private state
+  }, {
+    key: "setState",
+    value: function setState(updateObject) {
+      this.state = Object.assign({}, this.state, updateObject);
+    }
+
+    // Update private state.dimensions
+  }, {
+    key: "_setDimensionState",
+    value: function _setDimensionState(key, updateObject) {
+      this.setState({
+        dimensions: Object.assign({}, this.state.dimensions, (0, _defineProperty2["default"])({}, key, Object.assign({}, this.state.dimensions[key], updateObject)))
+      });
+    }
+  }, {
+    key: "_addAggregation",
+    value: function _addAggregation(aggregation) {
+      this.aggregationUpdater = aggregation;
+    }
+  }, {
+    key: "_addDimension",
+    value: function _addDimension() {
+      var _this = this;
+      var dimensions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      dimensions.forEach(function (dimension) {
+        var key = dimension.key;
+        _this.dimensionUpdaters[key] = dimension;
+      });
+    }
+  }, {
+    key: "_needUpdateStep",
+    value: function _needUpdateStep(dimensionStep, oldProps, props, changeFlags) {
+      // whether need to update current dimension step
+      // dimension step is the value, domain, scaleFunction of each dimension
+      // each step is an object with properties links to layer prop and whether the prop is
+      // controlled by updateTriggers
+      return Object.values(dimensionStep.triggers).some(function (item) {
+        if (item.updateTrigger) {
+          // check based on updateTriggers change first
+          return changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged[item.updateTrigger]);
+        }
+        // fallback to direct comparison
+        return oldProps[item.prop] !== props[item.prop];
+      });
+    }
+  }, {
+    key: "_accumulateUpdaters",
+    value: function _accumulateUpdaters(step, props, dimension) {
+      var updaters = [];
+      for (var i = step; i < dimension.updateSteps.length; i++) {
+        var updater = dimension.updateSteps[i].updater;
+        if (typeof updater === 'function') {
+          updaters.push(updater.bind(this, dimension.updateSteps[i], props, dimension));
+        }
+      }
+      return updaters;
+    }
+  }, {
+    key: "_getAllUpdaters",
+    value: function _getAllUpdaters(dimension, oldProps, props, changeFlags) {
+      var _this2 = this;
+      var updaters = [];
+      var needUpdateStep = dimension.updateSteps.findIndex(function (step) {
+        return _this2._needUpdateStep(step, oldProps, props, changeFlags);
+      });
+      if (needUpdateStep > -1) {
+        updaters = updaters.concat(this._accumulateUpdaters(needUpdateStep, props, dimension));
+      }
+      return updaters;
+    }
+  }, {
+    key: "_getAggregationChanges",
+    value: function _getAggregationChanges(oldProps, props, changeFlags) {
+      var updaters = this._getAllUpdaters(this.aggregationUpdater, oldProps, props, changeFlags);
+      return updaters.length ? updaters : null;
+    }
+  }, {
+    key: "_getDimensionChanges",
+    value: function _getDimensionChanges(oldProps, props, changeFlags) {
+      var updaters = [];
+
+      // get dimension to be updated
+      for (var key in this.dimensionUpdaters) {
+        // return the first triggered updater for each dimension
+        var dimension = this.dimensionUpdaters[key];
+        var dimensionUpdaters = this._getAllUpdaters(dimension, oldProps, props, changeFlags);
+        updaters = updaters.concat(dimensionUpdaters);
+      }
+      return updaters.length ? updaters : null;
+    }
+  }, {
+    key: "getUpdateTriggers",
+    value: function getUpdateTriggers(props) {
+      var _this3 = this;
+      var _updateTriggers = props.updateTriggers || {};
+      var updateTriggers = {};
+      var _loop = function _loop() {
+        var _this3$dimensionUpdat = _this3.dimensionUpdaters[key],
+          accessor = _this3$dimensionUpdat.accessor,
+          updateSteps = _this3$dimensionUpdat.updateSteps;
+        // fold dimension triggers into each accessor
+        updateTriggers[accessor] = {};
+        updateSteps.forEach(function (step) {
+          Object.values(step.triggers || []).forEach(function (_ref5) {
+            var prop = _ref5.prop,
+              updateTrigger = _ref5.updateTrigger;
+            if (updateTrigger) {
+              // if prop is based on updateTrigger e.g. getColorValue, getColorWeight
+              // and updateTriggers is passed in from layer prop
+              // fold the updateTriggers into accessor
+              var fromProp = _updateTriggers[updateTrigger];
+              if ((0, _typeof2["default"])(fromProp) === 'object' && !Array.isArray(fromProp)) {
+                // if updateTrigger is an object spread it
+                Object.assign(updateTriggers[accessor], fromProp);
+              } else if (fromProp !== undefined) {
+                updateTriggers[accessor][prop] = fromProp;
+              }
+            } else {
+              // if prop is not based on updateTrigger
+              updateTriggers[accessor][prop] = props[prop];
+            }
+          });
+        });
+      };
+      for (var key in this.dimensionUpdaters) {
+        _loop();
+      }
+      return updateTriggers;
+    }
+  }, {
+    key: "getPickingInfo",
+    value: function getPickingInfo(_ref6, layerProps) {
+      var _this$state$layerData;
+      var info = _ref6.info;
+      var isPicked = info.picked && info.index > -1;
+      var object = null;
+      var cell = isPicked ? (_this$state$layerData = this.state.layerData.data) === null || _this$state$layerData === void 0 ? void 0 : _this$state$layerData[info.index] : null;
+      if (cell) {
+        var binInfo = {};
+        for (var key in this.dimensionUpdaters) {
+          var _getPickingInfo = this.dimensionUpdaters[key].getPickingInfo;
+          if (typeof _getPickingInfo === 'function') {
+            binInfo = Object.assign({}, binInfo, _getPickingInfo(this.state.dimensions[key], cell, layerProps));
+          }
+        }
+        object = Object.assign(binInfo, cell, {
+          points: cell.filteredPoints || cell.points
+        });
+      }
+
+      // add bin  and  to info
+      return Object.assign(info, {
+        picked: Boolean(object),
+        // override object with picked cell
+        object: object
+      });
+    }
+  }, {
+    key: "getAccessor",
+    value: function getAccessor(dimensionKey, layerProps) {
+      if (!Object.prototype.hasOwnProperty.call(this.dimensionUpdaters, dimensionKey)) {
+        return nop;
+      }
+      return this.dimensionUpdaters[dimensionKey].getSubLayerAccessor(this.state.dimensions[dimensionKey], this.dimensionUpdaters[dimensionKey], layerProps);
+    }
+  }], [{
+    key: "defaultDimensions",
+    value: function defaultDimensions() {
+      return _defaultDimensions;
+    }
+  }]);
+}();
+(0, _defineProperty2["default"])(CPUAggregator, "getDimensionScale", void 0);
+CPUAggregator.getDimensionScale = getDimensionScale;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_window","require","_utils","_constants","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","_createForOfIteratorHelper","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","_n","F","s","n","done","value","f","TypeError","a","u","call","next","_arrayLikeToArray","toString","slice","constructor","name","from","test","AGGREGATION_OPERATION","SUM","MEAN","MIN","MAX","COUNT","MAX_32_BIT_FLOAT","defaultGetValue","points","defaultGetPoints","bin","defaultGetIndex","index","ascending","b","NaN","clamp","min","max","Math","getQuantileDomain","data","valueAccessor","map","sort","getOrdinalDomain","_toConsumableArray2","Set","BinSorter","bins","undefined","props","_classCallCheck2","aggregatedBins","_getAggregatedBins","_updateMinMaxValues","binMap","_getBinMap","_createClass2","key","_props$getValue","getValue","_props$getPoints","getPoints","_props$getIndex","getIndex","filterData","hasFilter","binIndex","i","filteredPoints","Number","isFinite","counts","maxCount","maxValue","minValue","totalCount","_iterator","_step","x","err","_iterator2","_step2","_percentileToIndex","percentileRange","len","sortedBins","_percentileRange$map","_percentileRange$map2","_slicedToArray2","lower","upper","ceil","floor","getValueDomainByScale","scale","_ref","_ref2","_ref2$","_ref2$2","indexEdge","_getScaleDomain","scaleType","_ref3","_ref4","lowerIdx","upperIdx","d","getValueRange","idxRange","DECK_AGGREGATION_MAP","exports","AGGREGATION_TYPES","sum","average","minimum","maximum","getValueFunc","aggregation","accessor","toUpperCase","Console","warn","concat","op","keplerOp","pts","aggregate","getScaleFunctor","SCALE_FUNC","quantize","nop","getGetValue","step","dimensionUpdater","_step$triggers","triggers","weight","prop","_setDimensionState","getDimensionSortedBins","state","dimensions","layerData","_filterData","getDimensionValueDomain","_step$triggers2","lowerPercentile","upperPercentile","valueDomain","colorScaleType","colorMap","reduce","prev","cur","getDimensionScale","_step$triggers3","domain","range","fixed","onSet","dimensionRange","dimensionDomain","dimensionFixed","Boolean","scaleFunctor","scaleFunc","_typeof2","normalizeResult","result","hexagons","assign","getAggregatedData","aggregationParams","aggr","aggregator","setState","defaultAggregation","updateSteps","cellSize","position","updateTrigger","updater","getSubLayerAccessor","dimensionState","dimension","cell","nullValue","cv","isValueInDomain","defaultColorDimension","getPickingInfo","colorValue","defaultElevationDimension","elevationValue","defaultDimensions","CPUAggregator","opts","initialState","dimensionUpdaters","aggregationUpdater","_addDimension","updateAllDimensions","dimensionChanges","dim","updaters","_accumulateUpdaters","updateAggregation","updateState","oldProps","changeFlags","dataChanged","aggregationChanges","_getAggregationChanges","_getDimensionChanges","updateObject","_addAggregation","_this","_needUpdateStep","dimensionStep","values","some","item","updateTriggersChanged","all","bind","_getAllUpdaters","_this2","needUpdateStep","findIndex","getUpdateTriggers","_this3","_updateTriggers","updateTriggers","_loop","_this3$dimensionUpdat","_ref5","fromProp","_ref6","layerProps","_this$state$layerData","info","isPicked","picked","object","binInfo","getAccessor","dimensionKey","prototype","hasOwnProperty"],"sources":["../../../src/layer-utils/cpu-aggregator.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n/* eslint-disable guard-for-in */\nimport {console as Console} from 'global/window';\n\nimport {aggregate} from '@kepler.gl/utils';\nimport {AGGREGATION_TYPES, SCALE_FUNC} from '@kepler.gl/constants';\nimport {RGBAColor} from '@kepler.gl/types';\nimport type ClusterBuilder from './cluster-utils';\n\nconst AGGREGATION_OPERATION = {\n  SUM: 'SUM' as const,\n  MEAN: 'MEAN' as const,\n  MIN: 'MIN' as const,\n  MAX: 'MAX' as const,\n  COUNT: 'COUNT' as const\n};\n\nconst MAX_32_BIT_FLOAT = 3.402823466e38;\n\ninterface Bin {\n  points: Record<string, unknown>[];\n  filteredPoints?: Record<string, unknown>[] | null;\n  index?: number;\n}\n\ninterface AggregatedBin {\n  i: number;\n  value: number;\n  counts: number;\n}\n\nconst defaultGetValue = (points: Record<string, unknown>[]) => points.length;\nconst defaultGetPoints = (bin: Bin) => bin.points;\nconst defaultGetIndex = (bin: Bin) => bin.index;\nconst ascending = (a: number, b: number) => (a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN);\n\nfunction clamp(value: number, min: number, max: number) {\n  return Math.max(min, Math.min(max, value));\n}\n\nfunction getQuantileDomain(data: AggregatedBin[], valueAccessor: (d: AggregatedBin) => number) {\n  return data.map(valueAccessor).sort(ascending);\n}\n\nfunction getOrdinalDomain(data: AggregatedBin[], valueAccessor: (d: AggregatedBin) => number) {\n  return [...new Set(data.map(valueAccessor))];\n}\n\nclass BinSorter {\n  maxCount!: number;\n  maxValue!: number;\n  minValue!: number;\n  totalCount!: number;\n  aggregatedBins: AggregatedBin[];\n  sortedBins!: AggregatedBin[];\n  binMap: Record<number, AggregatedBin>;\n\n  constructor(bins: Bin[] = [], props: Record<string, any> = {}) {\n    this.aggregatedBins = this._getAggregatedBins(bins, props);\n    this._updateMinMaxValues();\n    this.binMap = this._getBinMap();\n  }\n\n  _getAggregatedBins(bins: Bin[], props: Record<string, any>): AggregatedBin[] {\n    const {\n      getValue = defaultGetValue,\n      getPoints = defaultGetPoints,\n      getIndex = defaultGetIndex,\n      filterData\n    } = props;\n    const hasFilter = typeof filterData === 'function';\n    const aggregatedBins: AggregatedBin[] = [];\n    let index = 0;\n    for (let binIndex = 0; binIndex < bins.length; binIndex++) {\n      const bin = bins[binIndex];\n      const points = getPoints(bin);\n      const i = getIndex(bin);\n      const filteredPoints = hasFilter ? points.filter(filterData) : points;\n      bin.filteredPoints = hasFilter ? filteredPoints : null;\n      const value = filteredPoints.length ? getValue(filteredPoints) : null;\n      if (value !== null && value !== undefined) {\n        aggregatedBins[index] = {\n          i: Number.isFinite(i) ? i : binIndex,\n          value,\n          counts: filteredPoints.length\n        };\n        index++;\n      }\n    }\n    return aggregatedBins;\n  }\n\n  _updateMinMaxValues() {\n    let maxCount = 0;\n    let maxValue = -MAX_32_BIT_FLOAT;\n    let minValue = MAX_32_BIT_FLOAT;\n    let totalCount = 0;\n    for (const x of this.aggregatedBins) {\n      maxCount = maxCount > x.counts ? maxCount : x.counts;\n      maxValue = maxValue > x.value ? maxValue : x.value;\n      minValue = minValue < x.value ? minValue : x.value;\n      totalCount += x.counts;\n    }\n    if (this.aggregatedBins.length === 0) {\n      maxValue = 0;\n      minValue = 0;\n    }\n    this.maxCount = maxCount;\n    this.maxValue = maxValue;\n    this.minValue = minValue;\n    this.totalCount = totalCount;\n  }\n\n  _getBinMap() {\n    const binMap = {};\n    for (const bin of this.aggregatedBins) {\n      binMap[bin.i] = bin;\n    }\n    return binMap;\n  }\n\n  _percentileToIndex(percentileRange: number[]) {\n    const len = this.sortedBins.length;\n    if (len < 2) return [0, 0];\n    const [lower, upper] = percentileRange.map(n => clamp(n, 0, 100));\n    return [Math.ceil((lower / 100) * (len - 1)), Math.floor((upper / 100) * (len - 1))];\n  }\n\n  getValueDomainByScale(scale: string, [lower = 0, upper = 100]: number[] = []) {\n    if (!this.sortedBins) {\n      this.sortedBins = this.aggregatedBins.sort((a, b) => ascending(a.value, b.value));\n    }\n    if (!this.sortedBins.length) return [];\n    const indexEdge = this._percentileToIndex([lower, upper]);\n    return this._getScaleDomain(scale, indexEdge);\n  }\n\n  _getScaleDomain(scaleType: string, [lowerIdx, upperIdx]: number[]) {\n    const bins = this.sortedBins;\n    switch (scaleType) {\n      case 'quantize':\n      case 'linear':\n        return [bins[lowerIdx].value, bins[upperIdx].value];\n      case 'quantile':\n        return getQuantileDomain(bins.slice(lowerIdx, upperIdx + 1), d => d.value);\n      case 'ordinal':\n        return getOrdinalDomain(bins, d => d.value);\n      default:\n        return [bins[lowerIdx].value, bins[upperIdx].value];\n    }\n  }\n\n  getValueRange(percentileRange?: number[]) {\n    if (!this.sortedBins) {\n      this.sortedBins = this.aggregatedBins.sort((a, b) => ascending(a.value, b.value));\n    }\n    if (!this.sortedBins.length) return [];\n    let lowerIdx = 0;\n    let upperIdx = this.sortedBins.length - 1;\n    if (Array.isArray(percentileRange)) {\n      const idxRange = this._percentileToIndex(percentileRange);\n      lowerIdx = idxRange[0];\n      upperIdx = idxRange[1];\n    }\n    return [this.sortedBins[lowerIdx].value, this.sortedBins[upperIdx].value];\n  }\n}\n\nexport type UpdaterType = (this: CPUAggregator, step, props, dimensionUpdater) => void;\nexport type BindedUpdaterType = () => void;\nexport type AggregatedUpdaterType = (\n  this: CPUAggregator,\n  step,\n  props,\n  aggregation,\n  aggregationParams\n) => void;\nexport type BindedAggregatedUpdaterType = (aggregationParams) => void;\n\nexport type UpdateStepsType = {\n  key: string;\n  triggers: {\n    [key: string]: {\n      prop: string;\n      updateTrigger?: string;\n    };\n  };\n  onSet?: {\n    props: string;\n  };\n  updater: UpdaterType;\n};\n\nexport type DimensionType<ValueType = any> = {\n  key: string;\n  accessor: string;\n  getPickingInfo: (dimensionState, cell, layerProps?) => any;\n  nullValue: ValueType;\n  updateSteps: UpdateStepsType[];\n  getSubLayerAccessor;\n};\n\nexport type AggregationUpdateStepsType = {\n  key: string;\n  triggers: {\n    [key: string]: {\n      prop: string;\n      updateTrigger?: string;\n    };\n  };\n  updater: AggregatedUpdaterType;\n};\n\nexport type AggregationType = {\n  key: string;\n  updateSteps: AggregationUpdateStepsType[];\n};\n\nexport const DECK_AGGREGATION_MAP = {\n  [AGGREGATION_OPERATION.SUM]: AGGREGATION_TYPES.sum,\n  [AGGREGATION_OPERATION.MEAN]: AGGREGATION_TYPES.average,\n  [AGGREGATION_OPERATION.MIN]: AGGREGATION_TYPES.minimum,\n  [AGGREGATION_OPERATION.MAX]: AGGREGATION_TYPES.maximum\n};\n\nexport function getValueFunc(\n  aggregation: string,\n  accessor: (d: Record<string, unknown>) => number\n) {\n  if (!aggregation || !AGGREGATION_OPERATION[aggregation.toUpperCase()]) {\n    Console.warn(`Aggregation ${aggregation} is not supported`);\n  }\n\n  const op = AGGREGATION_OPERATION[aggregation.toUpperCase()] || AGGREGATION_OPERATION.SUM;\n  const keplerOp = DECK_AGGREGATION_MAP[op];\n\n  return pts => aggregate(pts.map(accessor), keplerOp);\n}\n\nexport function getScaleFunctor(scaleType: string) {\n  if (!scaleType || !SCALE_FUNC[scaleType]) {\n    Console.warn(`Scale ${scaleType} is not supported`);\n  }\n  return SCALE_FUNC[scaleType] || SCALE_FUNC.quantize;\n}\n\nfunction nop() {\n  return;\n}\n\nexport function getGetValue(this: CPUAggregator, step, props, dimensionUpdater) {\n  const {key} = dimensionUpdater;\n  const {value, weight, aggregation} = step.triggers;\n\n  let getValue = props[value.prop];\n\n  if (getValue === null) {\n    // If `getValue` is not provided from props, build it with aggregation and weight.\n    getValue = getValueFunc(props[aggregation.prop], props[weight.prop]);\n  }\n\n  if (getValue) {\n    this._setDimensionState(key, {getValue});\n  }\n}\n\nexport function getDimensionSortedBins(this: CPUAggregator, step, props, dimensionUpdater) {\n  const {key} = dimensionUpdater;\n  const {getValue} = this.state.dimensions[key];\n  const sortedBins = new BinSorter((this.state.layerData.data || []) as unknown as Bin[], {\n    getValue,\n    filterData: props._filterData\n  });\n  this._setDimensionState(key, {sortedBins});\n}\n\nexport function getDimensionValueDomain(this: CPUAggregator, step, props, dimensionUpdater) {\n  const {key} = dimensionUpdater;\n  const {\n    triggers: {lowerPercentile, upperPercentile, scaleType}\n  } = step;\n\n  if (!this.state.dimensions[key].sortedBins) {\n    // the previous step should set sortedBins, if not, something went wrong\n    return;\n  }\n\n  let valueDomain =\n    // for log and sqrt scale, returns linear domain by default\n    // TODO: support other scale function domain in bin sorter\n    this.state.dimensions[key].sortedBins.getValueDomainByScale(props[scaleType.prop], [\n      props[lowerPercentile.prop],\n      props[upperPercentile.prop]\n    ]);\n\n  if (props.colorScaleType === 'custom' && props.colorMap) {\n    // for custom scale, return custom breaks as value domain directly\n    valueDomain = props.colorMap.reduce(\n      (prev, cur) => (Number.isFinite(cur[0]) ? prev.concat(cur[0]) : prev),\n      []\n    );\n  }\n\n  this._setDimensionState(key, {valueDomain});\n}\n\nexport function getDimensionScale(this: CPUAggregator, step, props, dimensionUpdater) {\n  const {key} = dimensionUpdater;\n  const {domain, range, scaleType, fixed} = step.triggers;\n  const {onSet} = step;\n  if (!this.state.dimensions[key].valueDomain) {\n    // the previous step should set valueDomain, if not, something went wrong\n    return;\n  }\n\n  const dimensionRange = props[range.prop];\n  const dimensionDomain = props[domain.prop] || this.state.dimensions[key].valueDomain;\n  const dimensionFixed = Boolean(fixed && props[fixed.prop]);\n\n  const scaleFunctor = getScaleFunctor(scaleType && props[scaleType.prop])();\n\n  const scaleFunc = scaleFunctor\n    .domain(dimensionDomain)\n    .range(dimensionFixed ? dimensionDomain : dimensionRange);\n  scaleFunc.scaleType = props.colorScaleType;\n\n  if (typeof onSet === 'object' && typeof props[onSet.props] === 'function') {\n    const sortedBins = this.state.dimensions[key].sortedBins;\n    if (sortedBins) {\n      props[onSet.props]({domain: scaleFunc.domain(), aggregatedBins: sortedBins.binMap});\n    }\n  }\n  this._setDimensionState(key, {scaleFunc});\n}\n\nfunction normalizeResult(\n  result: {\n    hexagons?: Record<string, unknown>[];\n    layerData?: Record<string, unknown>[];\n    data?: Record<string, unknown>[];\n  } = {}\n) {\n  // support previous hexagonAggregator API\n  if (result.hexagons) {\n    return Object.assign({data: result.hexagons}, result);\n  } else if (result.layerData) {\n    return Object.assign({data: result.layerData}, result);\n  }\n\n  return result;\n}\n\nexport function getAggregatedData(\n  this: CPUAggregator,\n  step,\n  props,\n  aggregation,\n  aggregationParams\n) {\n  const {\n    triggers: {aggregator: aggr}\n  } = step;\n  const aggregator = props[aggr.prop];\n\n  // result should contain a data array and other props\n  // result = {data: [], ...other props}\n  const result = aggregator(props, aggregationParams);\n  this.setState({\n    layerData: normalizeResult(result)\n  });\n}\n\nexport const defaultAggregation: AggregationType = {\n  key: 'position',\n  updateSteps: [\n    {\n      key: 'aggregate',\n      triggers: {\n        cellSize: {\n          prop: 'cellSize'\n        },\n        position: {\n          prop: 'getPosition',\n          updateTrigger: 'getPosition'\n        },\n        aggregator: {\n          prop: 'gridAggregator'\n        }\n      },\n      updater: getAggregatedData\n    }\n  ]\n};\n\nfunction getSubLayerAccessor(\n  dimensionState: {sortedBins: BinSorter; scaleFunc: ReturnType<typeof getScaleFunctor>},\n  dimension: DimensionType\n) {\n  return (cell: {index: number}) => {\n    const {sortedBins, scaleFunc} = dimensionState;\n    const bin = sortedBins.binMap[cell.index];\n\n    if (bin && bin.counts === 0) {\n      // no points left in bin after filtering\n      return dimension.nullValue;\n    }\n\n    const cv = bin && bin.value;\n    const domain = scaleFunc.domain();\n\n    const isValueInDomain =\n      scaleFunc.scaleType === 'custom'\n        ? cv >= sortedBins.minValue && cv <= sortedBins.maxValue\n        : cv >= domain[0] && cv <= domain[domain.length - 1];\n\n    // if cell value is outside domain, set alpha to 0\n    return isValueInDomain ? scaleFunc(cv) : dimension.nullValue;\n  };\n}\n\nexport const defaultColorDimension: DimensionType<RGBAColor> = {\n  key: 'fillColor',\n  accessor: 'getFillColor',\n  getPickingInfo: (dimensionState, cell) => {\n    if (!cell) {\n      return {};\n    }\n    const {sortedBins} = dimensionState;\n    const colorValue = sortedBins.binMap[cell.index] && sortedBins.binMap[cell.index].value;\n    return {colorValue};\n  },\n  nullValue: [0, 0, 0, 0],\n  updateSteps: [\n    {\n      key: 'getValue',\n      triggers: {\n        value: {\n          prop: 'getColorValue',\n          updateTrigger: 'getColorValue'\n        },\n        weight: {\n          prop: 'getColorWeight',\n          updateTrigger: 'getColorWeight'\n        },\n        aggregation: {\n          prop: 'colorAggregation'\n        }\n      },\n      updater: getGetValue\n    },\n    {\n      key: 'getBins',\n      triggers: {\n        _filterData: {\n          prop: '_filterData',\n          updateTrigger: '_filterData'\n        }\n      },\n      updater: getDimensionSortedBins\n    },\n    {\n      key: 'getDomain',\n      triggers: {\n        lowerPercentile: {\n          prop: 'lowerPercentile'\n        },\n        upperPercentile: {\n          prop: 'upperPercentile'\n        },\n        scaleType: {prop: 'colorScaleType'}\n      },\n      updater: getDimensionValueDomain\n    },\n    {\n      key: 'getScaleFunc',\n      triggers: {\n        domain: {prop: 'colorDomain'},\n        range: {prop: 'colorRange'},\n        scaleType: {prop: 'colorScaleType'}\n      },\n      onSet: {\n        props: 'onSetColorDomain'\n      },\n      updater: getDimensionScale\n    }\n  ],\n  getSubLayerAccessor\n};\n\nexport const defaultElevationDimension: DimensionType<number> = {\n  key: 'elevation',\n  accessor: 'getElevation',\n  getPickingInfo: (dimensionState, cell) => {\n    if (!cell) {\n      return {};\n    }\n    const {sortedBins} = dimensionState;\n    const elevationValue = sortedBins.binMap[cell.index] && sortedBins.binMap[cell.index].value;\n    return {elevationValue};\n  },\n  nullValue: -1,\n  updateSteps: [\n    {\n      key: 'getValue',\n      triggers: {\n        value: {\n          prop: 'getElevationValue',\n          updateTrigger: 'getElevationValue'\n        },\n        weight: {\n          prop: 'getElevationWeight',\n          updateTrigger: 'getElevationWeight'\n        },\n        aggregation: {\n          prop: 'elevationAggregation'\n        }\n      },\n      updater: getGetValue\n    },\n    {\n      key: 'getBins',\n      triggers: {\n        _filterData: {\n          prop: '_filterData',\n          updateTrigger: '_filterData'\n        }\n      },\n      updater: getDimensionSortedBins\n    },\n    {\n      key: 'getDomain',\n      triggers: {\n        lowerPercentile: {\n          prop: 'elevationLowerPercentile'\n        },\n        upperPercentile: {\n          prop: 'elevationUpperPercentile'\n        },\n        scaleType: {prop: 'elevationScaleType'}\n      },\n      updater: getDimensionValueDomain\n    },\n    {\n      key: 'getScaleFunc',\n      triggers: {\n        fixed: {prop: 'elevationFixed'},\n        domain: {prop: 'elevationDomain'},\n        range: {prop: 'elevationRange'},\n        scaleType: {prop: 'elevationScaleType'}\n      },\n      onSet: {\n        props: 'onSetElevationDomain'\n      },\n      updater: getDimensionScale\n    }\n  ],\n  getSubLayerAccessor\n};\n\nexport const defaultDimensions = [defaultColorDimension, defaultElevationDimension];\n\nexport type CPUAggregatorState = {\n  layerData: {data?: Record<string, unknown>[]};\n  dimensions: Record<\n    string,\n    {\n      getValue?: (...args: unknown[]) => number;\n      sortedBins?: BinSorter;\n      valueDomain?: number[];\n      scaleFunc?: ((...args: unknown[]) => unknown) & {domain: () => number[]; scaleType?: string};\n    }\n  >;\n  geoJSON?: GeoJSON.FeatureCollection;\n  clusterBuilder?: ClusterBuilder;\n};\n\nexport default class CPUAggregator {\n  static getDimensionScale: any;\n  state: CPUAggregatorState;\n  dimensionUpdaters: {[key: string]: DimensionType};\n  aggregationUpdater: AggregationType;\n\n  constructor(\n    opts: {\n      initialState?: CPUAggregatorState;\n      dimensions?: DimensionType[];\n      aggregation?: AggregationType;\n    } = {}\n  ) {\n    this.state = {\n      layerData: {},\n      dimensions: {\n        // color: {\n        //   getValue: null,\n        //   domain: null,\n        //   sortedBins: null,\n        //   scaleFunc: nop\n        // },\n        // elevation: {\n        //   getValue: null,\n        //   domain: null,\n        //   sortedBins: null,\n        //   scaleFunc: nop\n        // }\n      },\n      ...opts.initialState\n    };\n\n    this.dimensionUpdaters = {};\n    this.aggregationUpdater = opts.aggregation || defaultAggregation;\n\n    this._addDimension(opts.dimensions || defaultDimensions);\n  }\n\n  static defaultDimensions() {\n    return defaultDimensions;\n  }\n\n  updateAllDimensions(props: Record<string, any>) {\n    let dimensionChanges: BindedUpdaterType[] = [];\n    // update all dimensions\n    for (const dim in this.dimensionUpdaters) {\n      const updaters = this._accumulateUpdaters(0, props, this.dimensionUpdaters[dim]);\n      dimensionChanges = dimensionChanges.concat(updaters);\n    }\n\n    dimensionChanges.forEach(f => typeof f === 'function' && f());\n  }\n\n  updateAggregation(props: Record<string, any>, aggregationParams: Record<string, any>) {\n    const updaters = this._accumulateUpdaters(0, props, this.aggregationUpdater);\n    updaters.forEach(f => typeof f === 'function' && f(aggregationParams));\n  }\n\n  updateState(\n    opts: {\n      oldProps: Record<string, any>;\n      props: Record<string, any>;\n      changeFlags: Record<string, any>;\n    },\n    aggregationParams: Record<string, any>\n  ) {\n    const {oldProps, props, changeFlags} = opts;\n    let dimensionChanges: BindedUpdaterType[] = [];\n\n    if (changeFlags.dataChanged) {\n      // if data changed update everything\n      this.updateAggregation(props, aggregationParams);\n      this.updateAllDimensions(props);\n\n      return this.state;\n    }\n\n    const aggregationChanges = this._getAggregationChanges(oldProps, props, changeFlags);\n\n    if (aggregationChanges && aggregationChanges.length) {\n      // get aggregatedData\n      aggregationChanges.forEach(f => typeof f === 'function' && f(aggregationParams));\n      this.updateAllDimensions(props);\n    } else {\n      // only update dimensions\n      dimensionChanges = this._getDimensionChanges(oldProps, props, changeFlags) || [];\n      dimensionChanges.forEach(f => typeof f === 'function' && f());\n    }\n\n    return this.state;\n  }\n\n  // Update private state\n  setState(updateObject: Partial<CPUAggregatorState>) {\n    this.state = Object.assign({}, this.state, updateObject);\n  }\n\n  // Update private state.dimensions\n  _setDimensionState(key: string, updateObject: Record<string, any>) {\n    this.setState({\n      dimensions: Object.assign({}, this.state.dimensions, {\n        [key]: Object.assign({}, this.state.dimensions[key], updateObject)\n      })\n    });\n  }\n\n  _addAggregation(aggregation: AggregationType) {\n    this.aggregationUpdater = aggregation;\n  }\n\n  _addDimension(dimensions: DimensionType[] = []) {\n    dimensions.forEach(dimension => {\n      const {key} = dimension;\n      this.dimensionUpdaters[key] = dimension;\n    });\n  }\n\n  _needUpdateStep(\n    dimensionStep: UpdateStepsType | AggregationUpdateStepsType,\n    oldProps,\n    props,\n    changeFlags\n  ) {\n    // whether need to update current dimension step\n    // dimension step is the value, domain, scaleFunction of each dimension\n    // each step is an object with properties links to layer prop and whether the prop is\n    // controlled by updateTriggers\n    return Object.values(dimensionStep.triggers).some(item => {\n      if (item.updateTrigger) {\n        // check based on updateTriggers change first\n        return (\n          changeFlags.updateTriggersChanged &&\n          (changeFlags.updateTriggersChanged.all ||\n            changeFlags.updateTriggersChanged[item.updateTrigger])\n        );\n      }\n      // fallback to direct comparison\n      return oldProps[item.prop] !== props[item.prop];\n    });\n  }\n\n  _accumulateUpdaters<UpdaterObjectType extends DimensionType | AggregationType>(\n    step,\n    props,\n    dimension: UpdaterObjectType\n  ) {\n    type LocalUpdaterType = UpdaterObjectType extends DimensionType\n      ? BindedUpdaterType\n      : BindedAggregatedUpdaterType;\n    const updaters: LocalUpdaterType[] = [];\n    for (let i = step; i < dimension.updateSteps.length; i++) {\n      const updater = dimension.updateSteps[i].updater;\n      if (typeof updater === 'function') {\n        updaters.push(\n          (updater as UpdaterType).bind(\n            this,\n            dimension.updateSteps[i],\n            props,\n            dimension\n          ) as LocalUpdaterType\n        );\n      }\n    }\n\n    return updaters;\n  }\n\n  _getAllUpdaters<UpdaterObjectType extends DimensionType | AggregationType>(\n    dimension: UpdaterObjectType,\n    oldProps,\n    props,\n    changeFlags\n  ) {\n    type LocalUpdaterType = UpdaterObjectType extends DimensionType\n      ? BindedUpdaterType\n      : BindedAggregatedUpdaterType;\n    let updaters: LocalUpdaterType[] = [];\n    const needUpdateStep = dimension.updateSteps.findIndex(step =>\n      this._needUpdateStep(step, oldProps, props, changeFlags)\n    );\n\n    if (needUpdateStep > -1) {\n      updaters = updaters.concat(this._accumulateUpdaters(needUpdateStep, props, dimension));\n    }\n\n    return updaters;\n  }\n\n  _getAggregationChanges(\n    oldProps: Record<string, any>,\n    props: Record<string, any>,\n    changeFlags: Record<string, any>\n  ) {\n    const updaters = this._getAllUpdaters(this.aggregationUpdater, oldProps, props, changeFlags);\n    return updaters.length ? updaters : null;\n  }\n\n  _getDimensionChanges(\n    oldProps: Record<string, any>,\n    props: Record<string, any>,\n    changeFlags: Record<string, any>\n  ) {\n    let updaters: BindedUpdaterType[] = [];\n\n    // get dimension to be updated\n    for (const key in this.dimensionUpdaters) {\n      // return the first triggered updater for each dimension\n      const dimension = this.dimensionUpdaters[key];\n      const dimensionUpdaters = this._getAllUpdaters(dimension, oldProps, props, changeFlags);\n      updaters = updaters.concat(dimensionUpdaters);\n    }\n\n    return updaters.length ? updaters : null;\n  }\n\n  getUpdateTriggers(props: Record<string, any>) {\n    const _updateTriggers = props.updateTriggers || {};\n    const updateTriggers = {};\n\n    for (const key in this.dimensionUpdaters) {\n      const {accessor, updateSteps}: {accessor: string; updateSteps: UpdateStepsType[]} =\n        this.dimensionUpdaters[key];\n      // fold dimension triggers into each accessor\n      updateTriggers[accessor] = {};\n\n      updateSteps.forEach(step => {\n        Object.values(step.triggers || []).forEach(({prop, updateTrigger}) => {\n          if (updateTrigger) {\n            // if prop is based on updateTrigger e.g. getColorValue, getColorWeight\n            // and updateTriggers is passed in from layer prop\n            // fold the updateTriggers into accessor\n            const fromProp = _updateTriggers[updateTrigger];\n            if (typeof fromProp === 'object' && !Array.isArray(fromProp)) {\n              // if updateTrigger is an object spread it\n              Object.assign(updateTriggers[accessor], fromProp);\n            } else if (fromProp !== undefined) {\n              updateTriggers[accessor][prop] = fromProp;\n            }\n          } else {\n            // if prop is not based on updateTrigger\n            updateTriggers[accessor][prop] = props[prop];\n          }\n        });\n      });\n    }\n\n    return updateTriggers;\n  }\n\n  getPickingInfo({info}: {info: Record<string, any>}, layerProps: Record<string, any>) {\n    const isPicked = info.picked && info.index > -1;\n    let object: Record<string, any> | null = null;\n    const cell = isPicked ? this.state.layerData.data?.[info.index] : null;\n    if (cell) {\n      let binInfo = {};\n      for (const key in this.dimensionUpdaters) {\n        const {getPickingInfo} = this.dimensionUpdaters[key];\n        if (typeof getPickingInfo === 'function') {\n          binInfo = Object.assign(\n            {},\n            binInfo,\n            getPickingInfo(this.state.dimensions[key], cell, layerProps)\n          );\n        }\n      }\n\n      object = Object.assign(binInfo, cell, {\n        points: cell.filteredPoints || cell.points\n      });\n    }\n\n    // add bin  and  to info\n    return Object.assign(info, {\n      picked: Boolean(object),\n      // override object with picked cell\n      object\n    });\n  }\n\n  getAccessor(dimensionKey: string, layerProps: Record<string, any>) {\n    if (!Object.prototype.hasOwnProperty.call(this.dimensionUpdaters, dimensionKey)) {\n      return nop;\n    }\n    return this.dimensionUpdaters[dimensionKey].getSubLayerAccessor(\n      this.state.dimensions[dimensionKey],\n      this.dimensionUpdaters[dimensionKey],\n      layerProps\n    );\n  }\n}\n\nCPUAggregator.getDimensionScale = getDimensionScale;\n"],"mappings":"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","ignoreList":[]}