@kepler.gl/deckgl-layers 3.0.0-alpha.0

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

@@ -0,0 +1,669 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getValueFunc = getValueFunc;
+exports.getScaleFunctor = getScaleFunctor;
+exports.getGetValue = getGetValue;
+exports.getDimensionSortedBins = getDimensionSortedBins;
+exports.getDimensionValueDomain = getDimensionValueDomain;
+exports.getDimensionScale = getDimensionScale;
+exports.getAggregatedData = getAggregatedData;
+exports["default"] = exports.defaultDimensions = exports.defaultElevationDimension = exports.defaultColorDimension = exports.defaultAggregation = exports.DECK_AGGREGATION_MAP = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _aggregationLayers = require("@deck.gl/aggregation-layers");
+
+var _window = require("global/window");
+
+var _utils = require("@kepler.gl/utils");
+
+var _constants = require("@kepler.gl/constants");
+
+var _DECK_AGGREGATION_MAP;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var DECK_AGGREGATION_MAP = (_DECK_AGGREGATION_MAP = {}, (0, _defineProperty2["default"])(_DECK_AGGREGATION_MAP, _aggregationLayers.AGGREGATION_OPERATION.SUM, _constants.AGGREGATION_TYPES.sum), (0, _defineProperty2["default"])(_DECK_AGGREGATION_MAP, _aggregationLayers.AGGREGATION_OPERATION.MEAN, _constants.AGGREGATION_TYPES.average), (0, _defineProperty2["default"])(_DECK_AGGREGATION_MAP, _aggregationLayers.AGGREGATION_OPERATION.MIN, _constants.AGGREGATION_TYPES.minimum), (0, _defineProperty2["default"])(_DECK_AGGREGATION_MAP, _aggregationLayers.AGGREGATION_OPERATION.MAX, _constants.AGGREGATION_TYPES.maximum), _DECK_AGGREGATION_MAP);
+exports.DECK_AGGREGATION_MAP = DECK_AGGREGATION_MAP;
+
+function getValueFunc(aggregation, accessor) {
+  if (!aggregation || !_aggregationLayers.AGGREGATION_OPERATION[aggregation.toUpperCase()]) {
+    _window.console.warn("Aggregation ".concat(aggregation, " is not supported"));
+  }
+
+  var op = _aggregationLayers.AGGREGATION_OPERATION[aggregation.toUpperCase()] || _aggregationLayers.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() {}
+
+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; // @ts-expect-error
+
+  var sortedBins = new _aggregationLayers._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;
+  } // for log and sqrt scale, returns linear domain by default
+  // TODO: support other scale function domain in bin sorter
+
+
+  var valueDomain = this.state.dimensions[key].sortedBins.getValueDomainByScale(props[scaleType.prop], [props[lowerPercentile.prop], props[upperPercentile.prop]]);
+
+  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;
+  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 scaleFunctor = getScaleFunctor(scaleType && props[scaleType.prop])();
+  var scaleFunc = scaleFunctor.domain(dimensionDomain).range(dimensionRange);
+
+  if ((0, _typeof2["default"])(onSet) === 'object' && typeof props[onSet.props] === 'function') {
+    props[onSet.props](scaleFunc.domain());
+  }
+
+  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 = {
+  key: 'position',
+  updateSteps: [{
+    key: 'aggregate',
+    triggers: {
+      cellSize: {
+        prop: 'cellSize'
+      },
+      position: {
+        prop: 'getPosition',
+        updateTrigger: 'getPosition'
+      },
+      aggregator: {
+        prop: 'gridAggregator'
+      }
+    },
+    updater: getAggregatedData
+  }]
+};
+exports.defaultAggregation = defaultAggregation;
+
+function getSubLayerAccessor(dimensionState, dimension, layerProps) {
+  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 = 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 = {
+  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
+};
+exports.defaultColorDimension = defaultColorDimension;
+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: {
+      domain: {
+        prop: 'elevationDomain'
+      },
+      range: {
+        prop: 'elevationRange'
+      },
+      scaleType: {
+        prop: 'elevationScaleType'
+      }
+    },
+    onSet: {
+      props: 'onSetElevationDomain'
+    },
+    updater: getDimensionScale
+  }],
+  getSubLayerAccessor: getSubLayerAccessor
+};
+exports.defaultElevationDimension = defaultElevationDimension;
+var _defaultDimensions = [defaultColorDimension, defaultElevationDimension];
+exports.defaultDimensions = _defaultDimensions;
+
+var CPUAggregator = /*#__PURE__*/function () {
+  function CPUAggregator() {
+    var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2["default"])(this, CPUAggregator);
+    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);
+  }
+
+  (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(_key2) {
+        var _this3$dimensionUpdat = _this3.dimensionUpdaters[_key2],
+            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 (_ref) {
+            var prop = _ref.prop,
+                updateTrigger = _ref.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 _key2 in this.dimensionUpdaters) {
+        _loop(_key2);
+      }
+
+      return updateTriggers;
+    }
+  }, {
+    key: "getPickingInfo",
+    value: function getPickingInfo(_ref2, layerProps) {
+      var info = _ref2.info;
+      var isPicked = info.picked && info.index > -1;
+      var object = null;
+      var cell = isPicked ? this.state.layerData.data[info.index] : null;
+
+      if (cell) {
+        var binInfo = {};
+
+        for (var _key3 in this.dimensionUpdaters) {
+          var getPickingInfo = this.dimensionUpdaters[_key3].getPickingInfo;
+
+          if (typeof getPickingInfo === 'function') {
+            binInfo = Object.assign({}, binInfo, getPickingInfo(this.state.dimensions[_key3], 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 (!this.dimensionUpdaters.hasOwnProperty(dimensionKey)) {
+        return nop;
+      }
+
+      return this.dimensionUpdaters[dimensionKey].getSubLayerAccessor(this.state.dimensions[dimensionKey], this.dimensionUpdaters[dimensionKey], layerProps);
+    }
+  }], [{
+    key: "defaultDimensions",
+    value: function defaultDimensions() {
+      return _defaultDimensions;
+    }
+  }]);
+  return CPUAggregator;
+}();
+
+exports["default"] = CPUAggregator;
+CPUAggregator.getDimensionScale = getDimensionScale;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/layer-utils/cpu-aggregator.ts"],"names":["DECK_AGGREGATION_MAP","AGGREGATION_OPERATION","SUM","AGGREGATION_TYPES","sum","MEAN","average","MIN","minimum","MAX","maximum","getValueFunc","aggregation","accessor","toUpperCase","Console","warn","op","keplerOp","pts","map","getScaleFunctor","scaleType","SCALE_FUNC","quantize","nop","getGetValue","step","props","dimensionUpdater","key","triggers","value","weight","getValue","prop","_setDimensionState","getDimensionSortedBins","state","dimensions","sortedBins","BinSorter","layerData","data","filterData","_filterData","getDimensionValueDomain","lowerPercentile","upperPercentile","valueDomain","getValueDomainByScale","getDimensionScale","domain","range","onSet","dimensionRange","dimensionDomain","scaleFunctor","scaleFunc","normalizeResult","result","hexagons","Object","assign","getAggregatedData","aggregationParams","aggr","aggregator","setState","defaultAggregation","updateSteps","cellSize","position","updateTrigger","updater","getSubLayerAccessor","dimensionState","dimension","layerProps","cell","bin","binMap","index","counts","nullValue","cv","isValueInDomain","length","defaultColorDimension","getPickingInfo","colorValue","defaultElevationDimension","elevationValue","defaultDimensions","CPUAggregator","opts","initialState","dimensionUpdaters","aggregationUpdater","_addDimension","dimensionChanges","dim","updaters","_accumulateUpdaters","concat","forEach","f","oldProps","changeFlags","dataChanged","updateAggregation","updateAllDimensions","aggregationChanges","_getAggregationChanges","_getDimensionChanges","updateObject","dimensionStep","values","some","item","updateTriggersChanged","all","i","push","bind","needUpdateStep","findIndex","_needUpdateStep","_getAllUpdaters","_updateTriggers","updateTriggers","fromProp","Array","isArray","undefined","info","isPicked","picked","object","binInfo","points","filteredPoints","Boolean","dimensionKey","hasOwnProperty"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/* eslint-disable guard-for-in */\nimport {AGGREGATION_OPERATION, _BinSorter as BinSorter} from '@deck.gl/aggregation-layers';\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';\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(aggregation, accessor) {\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) {\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\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  // @ts-expect-error\n  const sortedBins = new BinSorter(this.state.layerData.data || [], {\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  // for log and sqrt scale, returns linear domain by default\n  // TODO: support other scale function domain in bin sorter\n  const valueDomain = this.state.dimensions[key].sortedBins.getValueDomainByScale(\n    props[scaleType.prop],\n    [props[lowerPercentile.prop], props[upperPercentile.prop]]\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} = 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\n  const scaleFunctor = getScaleFunctor(scaleType && props[scaleType.prop])();\n\n  const scaleFunc = scaleFunctor.domain(dimensionDomain).range(dimensionRange);\n\n  if (typeof onSet === 'object' && typeof props[onSet.props] === 'function') {\n    props[onSet.props](scaleFunc.domain());\n  }\n  this._setDimensionState(key, {scaleFunc});\n}\n\nfunction normalizeResult(result: {hexagons?; layerData?} = {}) {\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(dimensionState, dimension, layerProps) {\n  return cell => {\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 = 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        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 = {layerData: {data?}; dimensions: {}; geoJSON?; clusterBuilder?};\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) {\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, aggregationParams) {\n    const updaters = this._accumulateUpdaters(0, props, this.aggregationUpdater);\n    updaters.forEach(f => typeof f === 'function' && f(aggregationParams));\n  }\n\n  updateState(opts, aggregationParams) {\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) {\n    this.state = Object.assign({}, this.state, updateObject);\n  }\n\n  // Update private state.dimensions\n  _setDimensionState(key, updateObject) {\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.bind(this, dimension.updateSteps[i], props, dimension) 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(oldProps, props, changeFlags) {\n    const updaters = this._getAllUpdaters(this.aggregationUpdater, oldProps, props, changeFlags);\n    return updaters.length ? updaters : null;\n  }\n\n  _getDimensionChanges(oldProps, props, changeFlags) {\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) {\n    const _updateTriggers = props.updateTriggers || {};\n    const updateTriggers = {};\n\n    for (const key in this.dimensionUpdaters) {\n      const {\n        accessor,\n        updateSteps\n      }: {accessor; updateSteps: UpdateStepsType[]} = 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}, layerProps) {\n    const isPicked = info.picked && info.index > -1;\n    let object = 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, layerProps) {\n    if (!this.dimensionUpdaters.hasOwnProperty(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"]}