@deck.gl/aggregation-layers 8.6.2 → 8.6.3

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

@@ -7,28 +7,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
 var _binSorter = _interopRequireDefault(require("./bin-sorter"));
 
 var _scaleUtils = require("./scale-utils");
 
 var _aggregationOperationUtils = require("./aggregation-operation-utils");
 
-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; }
-
 function nop() {}
 
-var dimensionSteps = ['getBins', 'getDomain', 'getScaleFunc'];
-var _defaultDimensions = [{
+const dimensionSteps = ['getBins', 'getDomain', 'getScaleFunc'];
+const defaultDimensions = [{
   key: 'fillColor',
   accessor: 'getFillColor',
   pickingInfo: 'colorValue',
@@ -130,13 +118,10 @@ var _defaultDimensions = [{
   nullValue: -1
 }];
 
-var defaultGetCellSize = function defaultGetCellSize(props) {
-  return props.cellSize;
-};
+const defaultGetCellSize = props => props.cellSize;
 
-var CPUAggregator = function () {
-  function CPUAggregator(opts) {
-    (0, _classCallCheck2.default)(this, CPUAggregator);
+class CPUAggregator {
+  constructor(opts) {
     this.state = {
       layerData: {},
       dimensions: {}
@@ -146,370 +131,366 @@ var CPUAggregator = function () {
     this._getCellSize = opts.getCellSize || defaultGetCellSize;
     this._getAggregator = opts.getAggregator;
 
-    this._addDimension(opts.dimensions || _defaultDimensions);
+    this._addDimension(opts.dimensions || defaultDimensions);
   }
 
-  (0, _createClass2.default)(CPUAggregator, [{
-    key: "updateState",
-    value: function updateState(opts, aggregationParams) {
-      var oldProps = opts.oldProps,
-          props = opts.props,
-          changeFlags = opts.changeFlags;
-      this.updateGetValueFuncs(oldProps, props, changeFlags);
-      var reprojectNeeded = this.needsReProjectPoints(oldProps, props, changeFlags);
-      var aggregationDirty = false;
-
-      if (changeFlags.dataChanged || reprojectNeeded) {
-        this.getAggregatedData(props, aggregationParams);
-        aggregationDirty = true;
-      } else {
-        var dimensionChanges = this.getDimensionChanges(oldProps, props, changeFlags) || [];
-        dimensionChanges.forEach(function (f) {
-          return typeof f === 'function' && f();
-        });
-        aggregationDirty = true;
-      }
+  static defaultDimensions() {
+    return defaultDimensions;
+  }
 
-      this.setState({
-        aggregationDirty: aggregationDirty
-      });
-      return this.state;
-    }
-  }, {
-    key: "setState",
-    value: function setState(updateObject) {
-      this.state = _objectSpread(_objectSpread({}, this.state), updateObject);
+  updateState(opts, aggregationParams) {
+    const {
+      oldProps,
+      props,
+      changeFlags
+    } = opts;
+    this.updateGetValueFuncs(oldProps, props, changeFlags);
+    const reprojectNeeded = this.needsReProjectPoints(oldProps, props, changeFlags);
+    let aggregationDirty = false;
+
+    if (changeFlags.dataChanged || reprojectNeeded) {
+      this.getAggregatedData(props, aggregationParams);
+      aggregationDirty = true;
+    } else {
+      const dimensionChanges = this.getDimensionChanges(oldProps, props, changeFlags) || [];
+      dimensionChanges.forEach(f => typeof f === 'function' && f());
+      aggregationDirty = true;
     }
-  }, {
-    key: "setDimensionState",
-    value: function setDimensionState(key, updateObject) {
-      this.setState({
-        dimensions: _objectSpread(_objectSpread({}, this.state.dimensions), {}, (0, _defineProperty2.default)({}, key, _objectSpread(_objectSpread({}, this.state.dimensions[key]), updateObject)))
-      });
-    }
-  }, {
-    key: "normalizeResult",
-    value: function normalizeResult() {
-      var result = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
-      if (result.hexagons) {
-        return _objectSpread({
-          data: result.hexagons
-        }, result);
-      } else if (result.layerData) {
-        return _objectSpread({
-          data: result.layerData
-        }, result);
+
+    this.setState({
+      aggregationDirty
+    });
+    return this.state;
+  }
+
+  setState(updateObject) {
+    this.state = { ...this.state,
+      ...updateObject
+    };
+  }
+
+  setDimensionState(key, updateObject) {
+    this.setState({
+      dimensions: { ...this.state.dimensions,
+        [key]: { ...this.state.dimensions[key],
+          ...updateObject
+        }
       }
+    });
+  }
 
-      return result;
-    }
-  }, {
-    key: "getAggregatedData",
-    value: function getAggregatedData(props, aggregationParams) {
-      var aggregator = this._getAggregator(props);
-
-      var result = aggregator(props, aggregationParams);
-      this.setState({
-        layerData: this.normalizeResult(result)
-      });
-      this.changeFlags = {
-        layerData: true
+  normalizeResult(result = {}) {
+    if (result.hexagons) {
+      return {
+        data: result.hexagons,
+        ...result
+      };
+    } else if (result.layerData) {
+      return {
+        data: result.layerData,
+        ...result
       };
-      this.getSortedBins(props);
     }
-  }, {
-    key: "updateGetValueFuncs",
-    value: function updateGetValueFuncs(oldProps, props, changeFlags) {
-      for (var key in this.dimensionUpdaters) {
-        var _this$dimensionUpdate = this.dimensionUpdaters[key].getBins.triggers,
-            value = _this$dimensionUpdate.value,
-            weight = _this$dimensionUpdate.weight,
-            aggregation = _this$dimensionUpdate.aggregation;
-        var getValue = props[value.prop];
-        var getValueChanged = this.needUpdateDimensionStep(this.dimensionUpdaters[key].getBins, oldProps, props, changeFlags);
-
-        if (getValueChanged) {
-          if (getValue) {
-            getValue = (0, _aggregationOperationUtils.wrapGetValueFunc)(getValue, {
-              data: props.data
-            });
-          } else {
-            getValue = (0, _aggregationOperationUtils.getValueFunc)(props[aggregation.prop], props[weight.prop], {
-              data: props.data
-            });
-          }
-        }
 
+    return result;
+  }
+
+  getAggregatedData(props, aggregationParams) {
+    const aggregator = this._getAggregator(props);
+
+    const result = aggregator(props, aggregationParams);
+    this.setState({
+      layerData: this.normalizeResult(result)
+    });
+    this.changeFlags = {
+      layerData: true
+    };
+    this.getSortedBins(props);
+  }
+
+  updateGetValueFuncs(oldProps, props, changeFlags) {
+    for (const key in this.dimensionUpdaters) {
+      const {
+        value,
+        weight,
+        aggregation
+      } = this.dimensionUpdaters[key].getBins.triggers;
+      let getValue = props[value.prop];
+      const getValueChanged = this.needUpdateDimensionStep(this.dimensionUpdaters[key].getBins, oldProps, props, changeFlags);
+
+      if (getValueChanged) {
         if (getValue) {
-          this.setDimensionState(key, {
-            getValue: getValue
+          getValue = (0, _aggregationOperationUtils.wrapGetValueFunc)(getValue, {
+            data: props.data
+          });
+        } else {
+          getValue = (0, _aggregationOperationUtils.getValueFunc)(props[aggregation.prop], props[weight.prop], {
+            data: props.data
           });
         }
       }
-    }
-  }, {
-    key: "needsReProjectPoints",
-    value: function needsReProjectPoints(oldProps, props, changeFlags) {
-      return this._getCellSize(oldProps) !== this._getCellSize(props) || this._getAggregator(oldProps) !== this._getAggregator(props) || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPosition);
-    }
-  }, {
-    key: "addDimension",
-    value: function addDimension(dimensions) {
-      this._addDimension(dimensions);
-    }
-  }, {
-    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] = _this.getDimensionUpdaters(dimension);
-        _this.state.dimensions[key] = {
-          getValue: null,
-          domain: null,
-          sortedBins: null,
-          scaleFunc: nop
-        };
-      });
-    }
-  }, {
-    key: "getDimensionUpdaters",
-    value: function getDimensionUpdaters(_ref) {
-      var key = _ref.key,
-          accessor = _ref.accessor,
-          pickingInfo = _ref.pickingInfo,
-          getBins = _ref.getBins,
-          getDomain = _ref.getDomain,
-          getScaleFunc = _ref.getScaleFunc,
-          nullValue = _ref.nullValue;
-      return {
-        key: key,
-        accessor: accessor,
-        pickingInfo: pickingInfo,
-        getBins: _objectSpread({
-          updater: this.getDimensionSortedBins
-        }, getBins),
-        getDomain: _objectSpread({
-          updater: this.getDimensionValueDomain
-        }, getDomain),
-        getScaleFunc: _objectSpread({
-          updater: this.getDimensionScale
-        }, getScaleFunc),
-        attributeAccessor: this.getSubLayerDimensionAttribute(key, nullValue)
-      };
-    }
-  }, {
-    key: "needUpdateDimensionStep",
-    value: function needUpdateDimensionStep(dimensionStep, oldProps, props, changeFlags) {
-      return Object.values(dimensionStep.triggers).some(function (item) {
-        if (item.updateTrigger) {
-          return changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged[item.updateTrigger]);
-        }
 
-        return oldProps[item.prop] !== props[item.prop];
-      });
+      if (getValue) {
+        this.setDimensionState(key, {
+          getValue
+        });
+      }
     }
-  }, {
-    key: "getDimensionChanges",
-    value: function getDimensionChanges(oldProps, props, changeFlags) {
-      var _this2 = this;
+  }
 
-      var updaters = [];
+  needsReProjectPoints(oldProps, props, changeFlags) {
+    return this._getCellSize(oldProps) !== this._getCellSize(props) || this._getAggregator(oldProps) !== this._getAggregator(props) || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPosition);
+  }
 
-      var _loop = function _loop(key) {
-        var needUpdate = dimensionSteps.find(function (step) {
-          return _this2.needUpdateDimensionStep(_this2.dimensionUpdaters[key][step], oldProps, props, changeFlags);
-        });
+  addDimension(dimensions) {
+    this._addDimension(dimensions);
+  }
 
-        if (needUpdate) {
-          updaters.push(_this2.dimensionUpdaters[key][needUpdate].updater.bind(_this2, props, _this2.dimensionUpdaters[key]));
-        }
+  _addDimension(dimensions = []) {
+    dimensions.forEach(dimension => {
+      const {
+        key
+      } = dimension;
+      this.dimensionUpdaters[key] = this.getDimensionUpdaters(dimension);
+      this.state.dimensions[key] = {
+        getValue: null,
+        domain: null,
+        sortedBins: null,
+        scaleFunc: nop
       };
+    });
+  }
 
-      for (var key in this.dimensionUpdaters) {
-        _loop(key);
+  getDimensionUpdaters({
+    key,
+    accessor,
+    pickingInfo,
+    getBins,
+    getDomain,
+    getScaleFunc,
+    nullValue
+  }) {
+    return {
+      key,
+      accessor,
+      pickingInfo,
+      getBins: {
+        updater: this.getDimensionSortedBins,
+        ...getBins
+      },
+      getDomain: {
+        updater: this.getDimensionValueDomain,
+        ...getDomain
+      },
+      getScaleFunc: {
+        updater: this.getDimensionScale,
+        ...getScaleFunc
+      },
+      attributeAccessor: this.getSubLayerDimensionAttribute(key, nullValue)
+    };
+  }
+
+  needUpdateDimensionStep(dimensionStep, oldProps, props, changeFlags) {
+    return Object.values(dimensionStep.triggers).some(item => {
+      if (item.updateTrigger) {
+        return changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged[item.updateTrigger]);
       }
 
-      return updaters.length ? updaters : null;
-    }
-  }, {
-    key: "getUpdateTriggers",
-    value: function getUpdateTriggers(props) {
-      var _this3 = this;
-
-      var _updateTriggers = props.updateTriggers || {};
-
-      var updateTriggers = {};
-
-      var _loop2 = function _loop2(key) {
-        var accessor = _this3.dimensionUpdaters[key].accessor;
-        updateTriggers[accessor] = {};
-        dimensionSteps.forEach(function (step) {
-          Object.values(_this3.dimensionUpdaters[key][step].triggers).forEach(function (_ref2) {
-            var prop = _ref2.prop,
-                updateTrigger = _ref2.updateTrigger;
-
-            if (updateTrigger) {
-              var fromProp = _updateTriggers[updateTrigger];
-
-              if ((0, _typeof2.default)(fromProp) === 'object' && !Array.isArray(fromProp)) {
-                Object.assign(updateTriggers[accessor], fromProp);
-              } else if (fromProp !== undefined) {
-                updateTriggers[accessor][prop] = fromProp;
-              }
-            } else {
-              updateTriggers[accessor][prop] = props[prop];
-            }
-          });
-        });
-      };
+      return oldProps[item.prop] !== props[item.prop];
+    });
+  }
 
-      for (var key in this.dimensionUpdaters) {
-        _loop2(key);
-      }
+  getDimensionChanges(oldProps, props, changeFlags) {
+    const updaters = [];
 
-      return updateTriggers;
-    }
-  }, {
-    key: "getSortedBins",
-    value: function getSortedBins(props) {
-      for (var key in this.dimensionUpdaters) {
-        this.getDimensionSortedBins(props, this.dimensionUpdaters[key]);
+    for (const key in this.dimensionUpdaters) {
+      const needUpdate = dimensionSteps.find(step => this.needUpdateDimensionStep(this.dimensionUpdaters[key][step], oldProps, props, changeFlags));
+
+      if (needUpdate) {
+        updaters.push(this.dimensionUpdaters[key][needUpdate].updater.bind(this, props, this.dimensionUpdaters[key]));
       }
     }
-  }, {
-    key: "getDimensionSortedBins",
-    value: function getDimensionSortedBins(props, dimensionUpdater) {
-      var key = dimensionUpdater.key;
-      var getValue = this.state.dimensions[key].getValue;
-      var sortedBins = new _binSorter.default(this.state.layerData.data || [], {
-        getValue: getValue,
-        filterData: props._filterData
-      });
-      this.setDimensionState(key, {
-        sortedBins: sortedBins
-      });
-      this.getDimensionValueDomain(props, dimensionUpdater);
-    }
-  }, {
-    key: "getDimensionValueDomain",
-    value: function getDimensionValueDomain(props, dimensionUpdater) {
-      var getDomain = dimensionUpdater.getDomain,
-          key = dimensionUpdater.key;
-      var _getDomain$triggers = getDomain.triggers,
-          lowerPercentile = _getDomain$triggers.lowerPercentile,
-          upperPercentile = _getDomain$triggers.upperPercentile,
-          scaleType = _getDomain$triggers.scaleType;
-      var valueDomain = this.state.dimensions[key].sortedBins.getValueDomainByScale(props[scaleType.prop], [props[lowerPercentile.prop], props[upperPercentile.prop]]);
-      this.setDimensionState(key, {
-        valueDomain: valueDomain
-      });
-      this.getDimensionScale(props, dimensionUpdater);
-    }
-  }, {
-    key: "getDimensionScale",
-    value: function getDimensionScale(props, dimensionUpdater) {
-      var key = dimensionUpdater.key,
-          getScaleFunc = dimensionUpdater.getScaleFunc,
-          getDomain = dimensionUpdater.getDomain;
-      var _getScaleFunc$trigger = getScaleFunc.triggers,
-          domain = _getScaleFunc$trigger.domain,
-          range = _getScaleFunc$trigger.range;
-      var scaleType = getDomain.triggers.scaleType;
-      var onSet = getScaleFunc.onSet;
-      var dimensionRange = props[range.prop];
-      var dimensionDomain = props[domain.prop] || this.state.dimensions[key].valueDomain;
-      var getScaleFunction = (0, _scaleUtils.getScaleFunctionByScaleType)(scaleType && props[scaleType.prop]);
-      var scaleFunc = getScaleFunction(dimensionDomain, dimensionRange);
-
-      if ((0, _typeof2.default)(onSet) === 'object' && typeof props[onSet.props] === 'function') {
-        props[onSet.props](scaleFunc.domain());
-      }
 
-      this.setDimensionState(key, {
-        scaleFunc: scaleFunc
+    return updaters.length ? updaters : null;
+  }
+
+  getUpdateTriggers(props) {
+    const _updateTriggers = props.updateTriggers || {};
+
+    const updateTriggers = {};
+
+    for (const key in this.dimensionUpdaters) {
+      const {
+        accessor
+      } = this.dimensionUpdaters[key];
+      updateTriggers[accessor] = {};
+      dimensionSteps.forEach(step => {
+        Object.values(this.dimensionUpdaters[key][step].triggers).forEach(({
+          prop,
+          updateTrigger
+        }) => {
+          if (updateTrigger) {
+            const fromProp = _updateTriggers[updateTrigger];
+
+            if (typeof fromProp === 'object' && !Array.isArray(fromProp)) {
+              Object.assign(updateTriggers[accessor], fromProp);
+            } else if (fromProp !== undefined) {
+              updateTriggers[accessor][prop] = fromProp;
+            }
+          } else {
+            updateTriggers[accessor][prop] = props[prop];
+          }
+        });
       });
     }
-  }, {
-    key: "getSubLayerDimensionAttribute",
-    value: function getSubLayerDimensionAttribute(key, nullValue) {
-      var _this4 = this;
-
-      return function (cell) {
-        var _this4$state$dimensio = _this4.state.dimensions[key],
-            sortedBins = _this4$state$dimensio.sortedBins,
-            scaleFunc = _this4$state$dimensio.scaleFunc;
-        var bin = sortedBins.binMap[cell.index];
-
-        if (bin && bin.counts === 0) {
-          return nullValue;
-        }
 
-        var cv = bin && bin.value;
-        var domain = scaleFunc.domain();
-        var isValueInDomain = cv >= domain[0] && cv <= domain[domain.length - 1];
-        return isValueInDomain ? scaleFunc(cv) : nullValue;
-      };
+    return updateTriggers;
+  }
+
+  getSortedBins(props) {
+    for (const key in this.dimensionUpdaters) {
+      this.getDimensionSortedBins(props, this.dimensionUpdaters[key]);
     }
-  }, {
-    key: "getSubLayerAccessors",
-    value: function getSubLayerAccessors(props) {
-      var accessors = {};
-
-      for (var key in this.dimensionUpdaters) {
-        var accessor = this.dimensionUpdaters[key].accessor;
-        accessors[accessor] = this.getSubLayerDimensionAttribute(props, key);
+  }
+
+  getDimensionSortedBins(props, dimensionUpdater) {
+    const {
+      key
+    } = dimensionUpdater;
+    const {
+      getValue
+    } = this.state.dimensions[key];
+    const sortedBins = new _binSorter.default(this.state.layerData.data || [], {
+      getValue,
+      filterData: props._filterData
+    });
+    this.setDimensionState(key, {
+      sortedBins
+    });
+    this.getDimensionValueDomain(props, dimensionUpdater);
+  }
+
+  getDimensionValueDomain(props, dimensionUpdater) {
+    const {
+      getDomain,
+      key
+    } = dimensionUpdater;
+    const {
+      triggers: {
+        lowerPercentile,
+        upperPercentile,
+        scaleType
       }
+    } = getDomain;
+    const valueDomain = this.state.dimensions[key].sortedBins.getValueDomainByScale(props[scaleType.prop], [props[lowerPercentile.prop], props[upperPercentile.prop]]);
+    this.setDimensionState(key, {
+      valueDomain
+    });
+    this.getDimensionScale(props, dimensionUpdater);
+  }
 
-      return accessors;
+  getDimensionScale(props, dimensionUpdater) {
+    const {
+      key,
+      getScaleFunc,
+      getDomain
+    } = dimensionUpdater;
+    const {
+      domain,
+      range
+    } = getScaleFunc.triggers;
+    const {
+      scaleType
+    } = getDomain.triggers;
+    const {
+      onSet
+    } = getScaleFunc;
+    const dimensionRange = props[range.prop];
+    const dimensionDomain = props[domain.prop] || this.state.dimensions[key].valueDomain;
+    const getScaleFunction = (0, _scaleUtils.getScaleFunctionByScaleType)(scaleType && props[scaleType.prop]);
+    const scaleFunc = getScaleFunction(dimensionDomain, dimensionRange);
+
+    if (typeof onSet === 'object' && typeof props[onSet.props] === 'function') {
+      props[onSet.props](scaleFunc.domain());
     }
-  }, {
-    key: "getPickingInfo",
-    value: function getPickingInfo(_ref3) {
-      var info = _ref3.info;
-      var isPicked = info.picked && info.index > -1;
-      var object = null;
-
-      if (isPicked) {
-        var cell = this.state.layerData.data[info.index];
-        var binInfo = {};
-
-        for (var key in this.dimensionUpdaters) {
-          var pickingInfo = this.dimensionUpdaters[key].pickingInfo;
-          var sortedBins = this.state.dimensions[key].sortedBins;
-          var value = sortedBins.binMap[cell.index] && sortedBins.binMap[cell.index].value;
-          binInfo[pickingInfo] = value;
-        }
 
-        object = Object.assign(binInfo, cell, {
-          points: cell.filteredPoints || cell.points
-        });
+    this.setDimensionState(key, {
+      scaleFunc
+    });
+  }
+
+  getSubLayerDimensionAttribute(key, nullValue) {
+    return cell => {
+      const {
+        sortedBins,
+        scaleFunc
+      } = this.state.dimensions[key];
+      const bin = sortedBins.binMap[cell.index];
+
+      if (bin && bin.counts === 0) {
+        return nullValue;
       }
 
-      info.picked = Boolean(object);
-      info.object = object;
-      return info;
+      const cv = bin && bin.value;
+      const domain = scaleFunc.domain();
+      const isValueInDomain = cv >= domain[0] && cv <= domain[domain.length - 1];
+      return isValueInDomain ? scaleFunc(cv) : nullValue;
+    };
+  }
+
+  getSubLayerAccessors(props) {
+    const accessors = {};
+
+    for (const key in this.dimensionUpdaters) {
+      const {
+        accessor
+      } = this.dimensionUpdaters[key];
+      accessors[accessor] = this.getSubLayerDimensionAttribute(props, key);
     }
-  }, {
-    key: "getAccessor",
-    value: function getAccessor(dimensionKey) {
-      if (!this.dimensionUpdaters.hasOwnProperty(dimensionKey)) {
-        return nop;
+
+    return accessors;
+  }
+
+  getPickingInfo({
+    info
+  }) {
+    const isPicked = info.picked && info.index > -1;
+    let object = null;
+
+    if (isPicked) {
+      const cell = this.state.layerData.data[info.index];
+      const binInfo = {};
+
+      for (const key in this.dimensionUpdaters) {
+        const {
+          pickingInfo
+        } = this.dimensionUpdaters[key];
+        const {
+          sortedBins
+        } = this.state.dimensions[key];
+        const value = sortedBins.binMap[cell.index] && sortedBins.binMap[cell.index].value;
+        binInfo[pickingInfo] = value;
       }
 
-      return this.dimensionUpdaters[dimensionKey].attributeAccessor;
+      object = Object.assign(binInfo, cell, {
+        points: cell.filteredPoints || cell.points
+      });
     }
-  }], [{
-    key: "defaultDimensions",
-    value: function defaultDimensions() {
-      return _defaultDimensions;
+
+    info.picked = Boolean(object);
+    info.object = object;
+    return info;
+  }
+
+  getAccessor(dimensionKey) {
+    if (!this.dimensionUpdaters.hasOwnProperty(dimensionKey)) {
+      return nop;
     }
-  }]);
-  return CPUAggregator;
-}();
+
+    return this.dimensionUpdaters[dimensionKey].attributeAccessor;
+  }
+
+}
 
 exports.default = CPUAggregator;
 //# sourceMappingURL=cpu-aggregator.js.map