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

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

@@ -0,0 +1,788 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+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 _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 */
+import { console as Console } from 'global/window';
+import { aggregate } from '@kepler.gl/utils';
+import { AGGREGATION_TYPES, SCALE_FUNC } from '@kepler.gl/constants';
+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 _toConsumableArray(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] : {};
+    _classCallCheck(this, BinSorter);
+    _defineProperty(this, "maxCount", void 0);
+    _defineProperty(this, "maxValue", void 0);
+    _defineProperty(this, "minValue", void 0);
+    _defineProperty(this, "totalCount", void 0);
+    _defineProperty(this, "aggregatedBins", void 0);
+    _defineProperty(this, "sortedBins", void 0);
+    _defineProperty(this, "binMap", void 0);
+    this.aggregatedBins = this._getAggregatedBins(bins, props);
+    this._updateMinMaxValues();
+    this.binMap = this._getBinMap();
+  }
+  return _createClass(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 = _slicedToArray(_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 = _slicedToArray(_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 = _slicedToArray(_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];
+    }
+  }]);
+}();
+export var DECK_AGGREGATION_MAP = _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, AGGREGATION_OPERATION.SUM, AGGREGATION_TYPES.sum), AGGREGATION_OPERATION.MEAN, AGGREGATION_TYPES.average), AGGREGATION_OPERATION.MIN, AGGREGATION_TYPES.minimum), AGGREGATION_OPERATION.MAX, AGGREGATION_TYPES.maximum);
+export function getValueFunc(aggregation, accessor) {
+  if (!aggregation || !AGGREGATION_OPERATION[aggregation.toUpperCase()]) {
+    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 aggregate(pts.map(accessor), keplerOp);
+  };
+}
+export function getScaleFunctor(scaleType) {
+  if (!scaleType || !SCALE_FUNC[scaleType]) {
+    Console.warn("Scale ".concat(scaleType, " is not supported"));
+  }
+  return SCALE_FUNC[scaleType] || SCALE_FUNC.quantize;
+}
+function nop() {
+  return;
+}
+export 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
+    });
+  }
+}
+export 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
+  });
+}
+export 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
+  });
+}
+export 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 (_typeof(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;
+}
+export 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)
+  });
+}
+export var 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;
+  };
+}
+export var 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
+};
+export var 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 = [defaultColorDimension, defaultElevationDimension];
+export { _defaultDimensions as defaultDimensions };
+var CPUAggregator = /*#__PURE__*/function () {
+  function CPUAggregator() {
+    var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, CPUAggregator);
+    _defineProperty(this, "state", void 0);
+    _defineProperty(this, "dimensionUpdaters", void 0);
+    _defineProperty(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 _createClass(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, _defineProperty({}, 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 (_typeof(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;
+    }
+  }]);
+}();
+_defineProperty(CPUAggregator, "getDimensionScale", void 0);
+export { CPUAggregator as default };
+CPUAggregator.getDimensionScale = getDimensionScale;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["console","Console","aggregate","AGGREGATION_TYPES","SCALE_FUNC","AGGREGATION_OPERATION","SUM","MEAN","MIN","MAX","COUNT","MAX_32_BIT_FLOAT","defaultGetValue","points","length","defaultGetPoints","bin","defaultGetIndex","index","ascending","a","b","NaN","clamp","value","min","max","Math","getQuantileDomain","data","valueAccessor","map","sort","getOrdinalDomain","_toConsumableArray","Set","BinSorter","bins","arguments","undefined","props","_classCallCheck","_defineProperty","aggregatedBins","_getAggregatedBins","_updateMinMaxValues","binMap","_getBinMap","_createClass","key","_props$getValue","getValue","_props$getPoints","getPoints","_props$getIndex","getIndex","filterData","hasFilter","binIndex","i","filteredPoints","filter","Number","isFinite","counts","maxCount","maxValue","minValue","totalCount","_iterator","_createForOfIteratorHelper","_step","s","n","done","x","err","e","f","_iterator2","_step2","_percentileToIndex","percentileRange","len","sortedBins","_percentileRange$map","_percentileRange$map2","_slicedToArray","lower","upper","ceil","floor","getValueDomainByScale","scale","_ref","_ref2","_ref2$","_ref2$2","indexEdge","_getScaleDomain","scaleType","_ref3","_ref4","lowerIdx","upperIdx","slice","d","getValueRange","Array","isArray","idxRange","DECK_AGGREGATION_MAP","sum","average","minimum","maximum","getValueFunc","aggregation","accessor","toUpperCase","warn","concat","op","keplerOp","pts","getScaleFunctor","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","_typeof","normalizeResult","result","hexagons","Object","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","_defaultDimensions","CPUAggregator","opts","_objectSpread","initialState","dimensionUpdaters","aggregationUpdater","_addDimension","updateAllDimensions","dimensionChanges","dim","updaters","_accumulateUpdaters","forEach","updateAggregation","updateState","oldProps","changeFlags","dataChanged","aggregationChanges","_getAggregationChanges","_getDimensionChanges","updateObject","_addAggregation","_this","_needUpdateStep","dimensionStep","values","some","item","updateTriggersChanged","all","push","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","call","default"],"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":[]}