@carto/kepler.gl 0.0.1-alpha.map-libre

package/dist/layers/aggregation-layer.js

@@ -0,0 +1,416 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.aggregateRequiredColumns = exports.getFilterDataFunc = exports.getValueAggrFunc = exports.pointPosResolver = exports.pointPosAccessor = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _lodash = _interopRequireDefault(require("lodash.memoize"));
+
+var _baseLayer = _interopRequireDefault(require("./base-layer"));
+
+var _layerUtils = require("../utils/layer-utils");
+
+var _colorUtils = require("../utils/color-utils");
+
+var _aggregateUtils = require("../utils/aggregate-utils");
+
+var _defaultSettings = require("../constants/default-settings");
+
+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 _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var pointPosAccessor = function pointPosAccessor(_ref) {
+  var lat = _ref.lat,
+      lng = _ref.lng;
+  return function (dc) {
+    return function (d) {
+      return [dc.valueAt(d.index, lng.fieldIdx), dc.valueAt(d.index, lat.fieldIdx)];
+    };
+  };
+};
+
+exports.pointPosAccessor = pointPosAccessor;
+
+var pointPosResolver = function pointPosResolver(_ref2) {
+  var lat = _ref2.lat,
+      lng = _ref2.lng;
+  return "".concat(lat.fieldIdx, "-").concat(lng.fieldIdx);
+};
+
+exports.pointPosResolver = pointPosResolver;
+
+var getValueAggrFunc = function getValueAggrFunc(field, aggregation) {
+  return function (points) {
+    return field ? (0, _aggregateUtils.aggregate)(points.map(function (p) {
+      return field.valueAccessor(p.source ? p.source : p);
+    }), aggregation) : points.length;
+  };
+};
+
+exports.getValueAggrFunc = getValueAggrFunc;
+
+var getFilterDataFunc = function getFilterDataFunc(filterRange, getFilterValue) {
+  return function (pt) {
+    return getFilterValue(pt).every(function (val, i) {
+      return val >= filterRange[i][0] && val <= filterRange[i][1];
+    });
+  };
+};
+
+exports.getFilterDataFunc = getFilterDataFunc;
+
+var getLayerColorRange = function getLayerColorRange(colorRange) {
+  var colorMap = colorRange.colorMap;
+
+  if (colorMap) {
+    return colorMap.map(function (cMap) {
+      return (0, _colorUtils.hexToRgb)(cMap[1]);
+    });
+  }
+
+  return colorRange.colors.map(_colorUtils.hexToRgb);
+};
+
+var getLayerColorDomain = function getLayerColorDomain(colorDomain) {
+  var colorMap = colorDomain.colorMap;
+
+  if (colorMap) {
+    return colorMap.map(function (cMap) {
+      return cMap[0];
+    });
+  }
+
+  return null;
+};
+
+var aggregateRequiredColumns = ['lat', 'lng'];
+exports.aggregateRequiredColumns = aggregateRequiredColumns;
+
+var AggregationLayer = /*#__PURE__*/function (_Layer) {
+  (0, _inherits2["default"])(AggregationLayer, _Layer);
+
+  var _super = _createSuper(AggregationLayer);
+
+  function AggregationLayer(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, AggregationLayer);
+    _this = _super.call(this, props);
+
+    _this.getPositionAccessor = function (dataContainer) {
+      return pointPosAccessor(_this.config.columns)(dataContainer);
+    };
+
+    _this.getColorRange = (0, _lodash["default"])(getLayerColorRange);
+    _this.getColorDomain = (0, _lodash["default"])(getLayerColorDomain);
+    return _this;
+  }
+
+  (0, _createClass2["default"])(AggregationLayer, [{
+    key: "isAggregated",
+    get: function get() {
+      return true;
+    }
+  }, {
+    key: "requiredLayerColumns",
+    get: function get() {
+      return aggregateRequiredColumns;
+    }
+  }, {
+    key: "columnPairs",
+    get: function get() {
+      return this.defaultPointColumnPairs;
+    }
+  }, {
+    key: "noneLayerDataAffectingProps",
+    get: function get() {
+      return [].concat((0, _toConsumableArray2["default"])((0, _get2["default"])((0, _getPrototypeOf2["default"])(AggregationLayer.prototype), "noneLayerDataAffectingProps", this)), ['enable3d', 'colorRange', 'colorDomain', 'sizeRange', 'sizeScale', 'sizeDomain', 'percentile', 'coverage', 'elevationPercentile', 'elevationScale', 'enableElevationZoomFactor']);
+    }
+  }, {
+    key: "visualChannels",
+    get: function get() {
+      return {
+        color: {
+          aggregation: 'colorAggregation',
+          channelScaleType: _defaultSettings.CHANNEL_SCALES.colorAggr,
+          defaultMeasure: 'property.pointCount',
+          domain: 'colorDomain',
+          field: 'colorField',
+          key: 'color',
+          property: 'color',
+          range: 'colorRange',
+          scale: 'colorScale'
+        },
+        size: {
+          aggregation: 'sizeAggregation',
+          channelScaleType: _defaultSettings.CHANNEL_SCALES.sizeAggr,
+          condition: function condition(config) {
+            return config.visConfig.enable3d;
+          },
+          defaultMeasure: 'property.pointCount',
+          domain: 'sizeDomain',
+          field: 'sizeField',
+          key: 'size',
+          property: 'height',
+          range: 'sizeRange',
+          scale: 'sizeScale'
+        }
+      };
+    }
+    /**
+     * Get the description of a visualChannel config
+     * @param key
+     * @returns {{label: string, measure: (string|string)}}
+     */
+
+  }, {
+    key: "getVisualChannelDescription",
+    value: function getVisualChannelDescription(key) {
+      // e.g. label: Color, measure: Average of ETA
+      var _this$visualChannels$ = this.visualChannels[key],
+          range = _this$visualChannels$.range,
+          field = _this$visualChannels$.field,
+          defaultMeasure = _this$visualChannels$.defaultMeasure,
+          aggregation = _this$visualChannels$.aggregation;
+      var fieldConfig = this.config[field];
+      return {
+        label: this.visConfigSettings[range].label,
+        measure: fieldConfig ? "".concat(this.config.visConfig[aggregation], " of ").concat(fieldConfig.displayName || fieldConfig.name) : defaultMeasure
+      };
+    }
+  }, {
+    key: "getHoverData",
+    value: function getHoverData(object) {
+      // return aggregated object
+      return object;
+    }
+    /**
+     * Aggregation layer handles visual channel aggregation inside deck.gl layer
+     */
+
+  }, {
+    key: "updateLayerVisualChannel",
+    value: function updateLayerVisualChannel(_ref3, channel) {
+      var data = _ref3.data,
+          dataContainer = _ref3.dataContainer;
+      this.validateVisualChannel(channel);
+    }
+    /**
+     * Validate aggregation type on top of basic layer visual channel validation
+     * @param channel
+     */
+
+  }, {
+    key: "validateVisualChannel",
+    value: function validateVisualChannel(channel) {
+      // field type decides aggregation type decides scale type
+      this.validateFieldType(channel);
+      this.validateAggregationType(channel);
+      this.validateScale(channel);
+    }
+    /**
+     * Validate aggregation type based on selected field
+     */
+
+  }, {
+    key: "validateAggregationType",
+    value: function validateAggregationType(channel) {
+      var visualChannel = this.visualChannels[channel];
+      var field = visualChannel.field,
+          aggregation = visualChannel.aggregation;
+      var aggregationOptions = this.getAggregationOptions(channel);
+
+      if (!aggregation) {
+        return;
+      }
+
+      if (!aggregationOptions.length) {
+        // if field cannot be aggregated, set field to null
+        this.updateLayerConfig((0, _defineProperty2["default"])({}, field, null));
+      } else if (!aggregationOptions.includes(this.config.visConfig[aggregation])) {
+        // current aggregation type is not supported by this field
+        // set aggregation to the first supported option
+        this.updateLayerVisConfig((0, _defineProperty2["default"])({}, aggregation, aggregationOptions[0]));
+      }
+    }
+  }, {
+    key: "getAggregationOptions",
+    value: function getAggregationOptions(channel) {
+      var visualChannel = this.visualChannels[channel];
+      var field = visualChannel.field,
+          channelScaleType = visualChannel.channelScaleType;
+      return Object.keys(this.config[field] ? _defaultSettings.FIELD_OPTS[this.config[field].type].scale[channelScaleType] : _defaultSettings.DEFAULT_AGGREGATION[channelScaleType]);
+    }
+    /**
+     * Get scale options based on current field and aggregation type
+     * @param {string} channel
+     * @returns {string[]}
+     */
+
+  }, {
+    key: "getScaleOptions",
+    value: function getScaleOptions(channel) {
+      var visualChannel = this.visualChannels[channel];
+      var field = visualChannel.field,
+          aggregation = visualChannel.aggregation,
+          channelScaleType = visualChannel.channelScaleType;
+      var aggregationType = this.config.visConfig[aggregation];
+      return this.config[field] ? // scale options based on aggregation
+      _defaultSettings.FIELD_OPTS[this.config[field].type].scale[channelScaleType][aggregationType] : // default scale options for point count
+      _defaultSettings.DEFAULT_AGGREGATION[channelScaleType][aggregationType];
+    }
+    /**
+     * Aggregation layer handles visual channel aggregation inside deck.gl layer
+     */
+
+  }, {
+    key: "updateLayerDomain",
+    value: function updateLayerDomain(datasets, newFilter) {
+      return this;
+    }
+  }, {
+    key: "updateLayerMeta",
+    value: function updateLayerMeta(dataContainer, getPosition) {
+      // get bounds from points
+      var bounds = this.getPointsBounds(dataContainer, getPosition);
+      this.updateMeta({
+        bounds: bounds
+      });
+    }
+  }, {
+    key: "calculateDataAttribute",
+    value: function calculateDataAttribute(_ref4, getPosition) {
+      var dataContainer = _ref4.dataContainer,
+          filteredIndex = _ref4.filteredIndex;
+      var data = [];
+
+      for (var i = 0; i < filteredIndex.length; i++) {
+        var index = filteredIndex[i];
+        var pos = getPosition({
+          index: index
+        }); // if doesn't have point lat or lng, do not add the point
+        // deck.gl can't handle position = null
+
+        if (pos.every(Number.isFinite)) {
+          data.push({
+            index: index
+          });
+        }
+      }
+
+      return data;
+    }
+  }, {
+    key: "formatLayerData",
+    value: function formatLayerData(datasets, oldLayerData) {
+      var _datasets$this$config = datasets[this.config.dataId],
+          gpuFilter = _datasets$this$config.gpuFilter,
+          dataContainer = _datasets$this$config.dataContainer;
+      var getPosition = this.getPositionAccessor(dataContainer);
+      var getColorValue = getValueAggrFunc(this.config.colorField, this.config.visConfig.colorAggregation);
+      var getElevationValue = getValueAggrFunc(this.config.sizeField, this.config.visConfig.sizeAggregation);
+      var hasFilter = Object.values(gpuFilter.filterRange).some(function (arr) {
+        return arr.some(function (v) {
+          return v !== 0;
+        });
+      });
+      var getFilterValue = gpuFilter.filterValueAccessor(dataContainer)();
+      var filterData = hasFilter ? getFilterDataFunc(gpuFilter.filterRange, getFilterValue) : undefined;
+
+      var _this$updateData = this.updateData(datasets, oldLayerData),
+          data = _this$updateData.data;
+
+      return _objectSpread(_objectSpread({
+        data: data,
+        getPosition: getPosition,
+        _filterData: filterData
+      }, getColorValue ? {
+        getColorValue: getColorValue
+      } : {}), getElevationValue ? {
+        getElevationValue: getElevationValue
+      } : {});
+    }
+  }, {
+    key: "getDefaultDeckLayerProps",
+    value: function getDefaultDeckLayerProps(opts) {
+      var baseProp = (0, _get2["default"])((0, _getPrototypeOf2["default"])(AggregationLayer.prototype), "getDefaultDeckLayerProps", this).call(this, opts);
+      var maskExtensionProps = (0, _layerUtils.getMaskExtensionProps)(opts.maskPolygon);
+      return _objectSpread(_objectSpread(_objectSpread({}, baseProp), maskExtensionProps), {}, {
+        highlightColor: _defaultSettings.HIGHLIGH_COLOR_3D,
+        // gpu data filtering is not supported in aggregation layer
+        extensions: (0, _toConsumableArray2["default"])(maskExtensionProps.extensions),
+        autoHighlight: this.config.visConfig.enable3d
+      });
+    }
+  }, {
+    key: "getDefaultAggregationLayerProp",
+    value: function getDefaultAggregationLayerProp(opts) {
+      var gpuFilter = opts.gpuFilter,
+          _opts$layerCallbacks = opts.layerCallbacks,
+          layerCallbacks = _opts$layerCallbacks === void 0 ? {} : _opts$layerCallbacks;
+      var visConfig = this.config.visConfig;
+      var updateTriggers = {
+        getColorValue: {
+          colorField: this.config.colorField,
+          colorAggregation: this.config.visConfig.colorAggregation
+        },
+        getElevationValue: {
+          sizeField: this.config.sizeField,
+          sizeAggregation: this.config.visConfig.sizeAggregation
+        },
+        _filterData: _objectSpread({
+          filterRange: gpuFilter.filterRange
+        }, gpuFilter.filterValueUpdateTriggers)
+      };
+      return _objectSpread(_objectSpread({}, this.getDefaultDeckLayerProps(opts)), {}, {
+        coverage: visConfig.coverage,
+        // color
+        colorRange: this.getColorRange(visConfig.colorRange),
+        colorDomain: this.getColorDomain(visConfig.colorRange),
+        colorScaleType: this.config.colorScale,
+        upperPercentile: visConfig.percentile[1],
+        lowerPercentile: visConfig.percentile[0],
+        colorAggregation: visConfig.colorAggregation,
+        // elevation
+        extruded: visConfig.enable3d,
+        elevationScale: visConfig.elevationScale,
+        elevationScaleType: this.config.sizeScale,
+        elevationRange: visConfig.sizeRange,
+        elevationLowerPercentile: visConfig.elevationPercentile[0],
+        elevationUpperPercentile: visConfig.elevationPercentile[1],
+        // updateTriggers
+        updateTriggers: updateTriggers,
+        // callbacks
+        onSetColorDomain: layerCallbacks.onSetLayerDomain
+      });
+    }
+  }]);
+  return AggregationLayer;
+}(_baseLayer["default"]);
+
+exports["default"] = AggregationLayer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/layers/aggregation-layer.js"],"names":["pointPosAccessor","lat","lng","dc","d","valueAt","index","fieldIdx","pointPosResolver","getValueAggrFunc","field","aggregation","points","map","p","valueAccessor","source","length","getFilterDataFunc","filterRange","getFilterValue","pt","every","val","i","getLayerColorRange","colorRange","colorMap","cMap","colors","hexToRgb","getLayerColorDomain","colorDomain","aggregateRequiredColumns","AggregationLayer","props","getPositionAccessor","dataContainer","config","columns","getColorRange","getColorDomain","defaultPointColumnPairs","color","channelScaleType","CHANNEL_SCALES","colorAggr","defaultMeasure","domain","key","property","range","scale","size","sizeAggr","condition","visConfig","enable3d","visualChannels","fieldConfig","label","visConfigSettings","measure","displayName","name","object","channel","data","validateVisualChannel","validateFieldType","validateAggregationType","validateScale","visualChannel","aggregationOptions","getAggregationOptions","updateLayerConfig","includes","updateLayerVisConfig","Object","keys","FIELD_OPTS","type","DEFAULT_AGGREGATION","aggregationType","datasets","newFilter","getPosition","bounds","getPointsBounds","updateMeta","filteredIndex","pos","Number","isFinite","push","oldLayerData","dataId","gpuFilter","getColorValue","colorField","colorAggregation","getElevationValue","sizeField","sizeAggregation","hasFilter","values","some","arr","v","filterValueAccessor","filterData","undefined","updateData","_filterData","opts","baseProp","maskExtensionProps","maskPolygon","highlightColor","HIGHLIGH_COLOR_3D","extensions","autoHighlight","layerCallbacks","updateTriggers","filterValueUpdateTriggers","getDefaultDeckLayerProps","coverage","colorScaleType","colorScale","upperPercentile","percentile","lowerPercentile","extruded","elevationScale","elevationScaleType","sizeScale","elevationRange","sizeRange","elevationLowerPercentile","elevationPercentile","elevationUpperPercentile","onSetColorDomain","onSetLayerDomain","Layer"],"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\nimport memoize from 'lodash.memoize';\nimport Layer from './base-layer';\nimport {getMaskExtensionProps} from 'utils/layer-utils';\nimport {hexToRgb} from 'utils/color-utils';\nimport {aggregate} from 'utils/aggregate-utils';\nimport {\n  HIGHLIGH_COLOR_3D,\n  CHANNEL_SCALES,\n  FIELD_OPTS,\n  DEFAULT_AGGREGATION\n} from 'constants/default-settings';\n\nexport const pointPosAccessor = ({lat, lng}) => dc => d => [\n  dc.valueAt(d.index, lng.fieldIdx),\n  dc.valueAt(d.index, lat.fieldIdx)\n];\n\nexport const pointPosResolver = ({lat, lng}) => `${lat.fieldIdx}-${lng.fieldIdx}`;\n\nexport const getValueAggrFunc = (field, aggregation) => {\n  return points => {\n    return field\n      ? aggregate(\n          points.map(p => {\n            return field.valueAccessor(p.source ? p.source : p);\n          }),\n          aggregation\n        )\n      : points.length;\n  };\n};\n\nexport const getFilterDataFunc = (filterRange, getFilterValue) => pt =>\n  getFilterValue(pt).every((val, i) => val >= filterRange[i][0] && val <= filterRange[i][1]);\n\nconst getLayerColorRange = colorRange => {\n  const {colorMap} = colorRange;\n\n  if (colorMap) {\n    return colorMap.map(cMap => hexToRgb(cMap[1]));\n  }\n  return colorRange.colors.map(hexToRgb);\n};\n\nconst getLayerColorDomain = colorDomain => {\n  const {colorMap} = colorDomain;\n\n  if (colorMap) {\n    return colorMap.map(cMap => cMap[0]);\n  }\n  return null;\n};\n\nexport const aggregateRequiredColumns = ['lat', 'lng'];\n\nexport default class AggregationLayer extends Layer {\n  constructor(props) {\n    super(props);\n\n    this.getPositionAccessor = dataContainer =>\n      pointPosAccessor(this.config.columns)(dataContainer);\n    this.getColorRange = memoize(getLayerColorRange);\n    this.getColorDomain = memoize(getLayerColorDomain);\n  }\n\n  get isAggregated() {\n    return true;\n  }\n\n  get requiredLayerColumns() {\n    return aggregateRequiredColumns;\n  }\n\n  get columnPairs() {\n    return this.defaultPointColumnPairs;\n  }\n\n  get noneLayerDataAffectingProps() {\n    return [\n      ...super.noneLayerDataAffectingProps,\n      'enable3d',\n      'colorRange',\n      'colorDomain',\n      'sizeRange',\n      'sizeScale',\n      'sizeDomain',\n      'percentile',\n      'coverage',\n      'elevationPercentile',\n      'elevationScale',\n      'enableElevationZoomFactor'\n    ];\n  }\n\n  get visualChannels() {\n    return {\n      color: {\n        aggregation: 'colorAggregation',\n        channelScaleType: CHANNEL_SCALES.colorAggr,\n        defaultMeasure: 'property.pointCount',\n        domain: 'colorDomain',\n        field: 'colorField',\n        key: 'color',\n        property: 'color',\n        range: 'colorRange',\n        scale: 'colorScale'\n      },\n      size: {\n        aggregation: 'sizeAggregation',\n        channelScaleType: CHANNEL_SCALES.sizeAggr,\n        condition: config => config.visConfig.enable3d,\n        defaultMeasure: 'property.pointCount',\n        domain: 'sizeDomain',\n        field: 'sizeField',\n        key: 'size',\n        property: 'height',\n        range: 'sizeRange',\n        scale: 'sizeScale'\n      }\n    };\n  }\n\n  /**\n   * Get the description of a visualChannel config\n   * @param key\n   * @returns {{label: string, measure: (string|string)}}\n   */\n  getVisualChannelDescription(key) {\n    // e.g. label: Color, measure: Average of ETA\n    const {range, field, defaultMeasure, aggregation} = this.visualChannels[key];\n    const fieldConfig = this.config[field];\n    return {\n      label: this.visConfigSettings[range].label,\n      measure: fieldConfig\n        ? `${this.config.visConfig[aggregation]} of ${fieldConfig.displayName || fieldConfig.name}`\n        : defaultMeasure\n    };\n  }\n\n  getHoverData(object) {\n    // return aggregated object\n    return object;\n  }\n\n  /**\n   * Aggregation layer handles visual channel aggregation inside deck.gl layer\n   */\n  updateLayerVisualChannel({data, dataContainer}, channel) {\n    this.validateVisualChannel(channel);\n  }\n\n  /**\n   * Validate aggregation type on top of basic layer visual channel validation\n   * @param channel\n   */\n  validateVisualChannel(channel) {\n    // field type decides aggregation type decides scale type\n    this.validateFieldType(channel);\n    this.validateAggregationType(channel);\n    this.validateScale(channel);\n  }\n\n  /**\n   * Validate aggregation type based on selected field\n   */\n  validateAggregationType(channel) {\n    const visualChannel = this.visualChannels[channel];\n    const {field, aggregation} = visualChannel;\n    const aggregationOptions = this.getAggregationOptions(channel);\n\n    if (!aggregation) {\n      return;\n    }\n\n    if (!aggregationOptions.length) {\n      // if field cannot be aggregated, set field to null\n      this.updateLayerConfig({[field]: null});\n    } else if (!aggregationOptions.includes(this.config.visConfig[aggregation])) {\n      // current aggregation type is not supported by this field\n      // set aggregation to the first supported option\n      this.updateLayerVisConfig({[aggregation]: aggregationOptions[0]});\n    }\n  }\n\n  getAggregationOptions(channel) {\n    const visualChannel = this.visualChannels[channel];\n    const {field, channelScaleType} = visualChannel;\n\n    return Object.keys(\n      this.config[field]\n        ? FIELD_OPTS[this.config[field].type].scale[channelScaleType]\n        : DEFAULT_AGGREGATION[channelScaleType]\n    );\n  }\n\n  /**\n   * Get scale options based on current field and aggregation type\n   * @param {string} channel\n   * @returns {string[]}\n   */\n  getScaleOptions(channel) {\n    const visualChannel = this.visualChannels[channel];\n    const {field, aggregation, channelScaleType} = visualChannel;\n    const aggregationType = this.config.visConfig[aggregation];\n    return this.config[field]\n      ? // scale options based on aggregation\n        FIELD_OPTS[this.config[field].type].scale[channelScaleType][aggregationType]\n      : // default scale options for point count\n        DEFAULT_AGGREGATION[channelScaleType][aggregationType];\n  }\n\n  /**\n   * Aggregation layer handles visual channel aggregation inside deck.gl layer\n   */\n  updateLayerDomain(datasets, newFilter) {\n    return this;\n  }\n\n  updateLayerMeta(dataContainer, getPosition) {\n    // get bounds from points\n    const bounds = this.getPointsBounds(dataContainer, getPosition);\n\n    this.updateMeta({bounds});\n  }\n\n  calculateDataAttribute({dataContainer, filteredIndex}, getPosition) {\n    const data = [];\n\n    for (let i = 0; i < filteredIndex.length; i++) {\n      const index = filteredIndex[i];\n      const pos = getPosition({index});\n\n      // if doesn't have point lat or lng, do not add the point\n      // deck.gl can't handle position = null\n      if (pos.every(Number.isFinite)) {\n        data.push({\n          index\n        });\n      }\n    }\n\n    return data;\n  }\n\n  formatLayerData(datasets, oldLayerData) {\n    const {gpuFilter, dataContainer} = datasets[this.config.dataId];\n    const getPosition = this.getPositionAccessor(dataContainer);\n\n    const getColorValue = getValueAggrFunc(\n      this.config.colorField,\n      this.config.visConfig.colorAggregation\n    );\n\n    const getElevationValue = getValueAggrFunc(\n      this.config.sizeField,\n      this.config.visConfig.sizeAggregation\n    );\n    const hasFilter = Object.values(gpuFilter.filterRange).some(arr => arr.some(v => v !== 0));\n\n    const getFilterValue = gpuFilter.filterValueAccessor(dataContainer)();\n    const filterData = hasFilter\n      ? getFilterDataFunc(gpuFilter.filterRange, getFilterValue)\n      : undefined;\n\n    const {data} = this.updateData(datasets, oldLayerData);\n\n    return {\n      data,\n      getPosition,\n      _filterData: filterData,\n      ...(getColorValue ? {getColorValue} : {}),\n      ...(getElevationValue ? {getElevationValue} : {})\n    };\n  }\n\n  getDefaultDeckLayerProps(opts) {\n    const baseProp = super.getDefaultDeckLayerProps(opts);\n    const maskExtensionProps = getMaskExtensionProps(opts.maskPolygon);\n\n    return {\n      ...baseProp,\n      ...maskExtensionProps,\n      highlightColor: HIGHLIGH_COLOR_3D,\n      // gpu data filtering is not supported in aggregation layer\n      extensions: [...maskExtensionProps.extensions],\n      autoHighlight: this.config.visConfig.enable3d\n    };\n  }\n\n  getDefaultAggregationLayerProp(opts) {\n    const {gpuFilter, layerCallbacks = {}} = opts;\n    const {visConfig} = this.config;\n\n    const updateTriggers = {\n      getColorValue: {\n        colorField: this.config.colorField,\n        colorAggregation: this.config.visConfig.colorAggregation\n      },\n      getElevationValue: {\n        sizeField: this.config.sizeField,\n        sizeAggregation: this.config.visConfig.sizeAggregation\n      },\n      _filterData: {\n        filterRange: gpuFilter.filterRange,\n        ...gpuFilter.filterValueUpdateTriggers\n      }\n    };\n\n    return {\n      ...this.getDefaultDeckLayerProps(opts),\n      coverage: visConfig.coverage,\n\n      // color\n      colorRange: this.getColorRange(visConfig.colorRange),\n      colorDomain: this.getColorDomain(visConfig.colorRange),\n      colorScaleType: this.config.colorScale,\n      upperPercentile: visConfig.percentile[1],\n      lowerPercentile: visConfig.percentile[0],\n      colorAggregation: visConfig.colorAggregation,\n\n      // elevation\n      extruded: visConfig.enable3d,\n      elevationScale: visConfig.elevationScale,\n      elevationScaleType: this.config.sizeScale,\n      elevationRange: visConfig.sizeRange,\n      elevationLowerPercentile: visConfig.elevationPercentile[0],\n      elevationUpperPercentile: visConfig.elevationPercentile[1],\n\n      // updateTriggers\n      updateTriggers,\n\n      // callbacks\n      onSetColorDomain: layerCallbacks.onSetLayerDomain\n    };\n  }\n}\n"]}

package/dist/layers/arc-layer/arc-layer-icon.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _base = _interopRequireDefault(require("../../components/common/icons/base"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var ArcLayerIcon = /*#__PURE__*/function (_Component) {
+  (0, _inherits2["default"])(ArcLayerIcon, _Component);
+
+  var _super = _createSuper(ArcLayerIcon);
+
+  function ArcLayerIcon() {
+    (0, _classCallCheck2["default"])(this, ArcLayerIcon);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(ArcLayerIcon, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/_react["default"].createElement(_base["default"], this.props, /*#__PURE__*/_react["default"].createElement("path", {
+        d: "M34.5,34.4c-0.6,0-1.2-0.4-1.4-1c-2.7-9.9-8.8-21.7-16.8-22.3c-3.1-0.2-5.6,1.5-7,4.8c-0.3,0.7-1.1,1.1-1.9,0.7 c-0.7-0.3-1.1-1.1-0.7-1.9c1.9-4.3,5.6-6.8,9.8-6.5c9.5,0.7,16.3,13,19.4,24.4c0.2,0.8-0.2,1.5-1,1.7C34.8,34.3,34.6,34.4,34.5,34.4 z",
+        className: "cr1"
+      }), /*#__PURE__*/_react["default"].createElement("path", {
+        d: "M6.7,57c0,0-0.1,0-0.1,0c-0.5-0.1-0.9-0.6-0.8-1.1c2.4-17.3,9.6-30.3,17.5-31.8c3.1-0.6,7.8,0.4,12.1,8.3 c0.3,0.5,0.1,1-0.4,1.3c-0.5,0.3-1,0.1-1.3-0.4c-2.1-3.8-5.6-8.2-10.1-7.4C16.6,27.3,9.9,40,7.6,56.2C7.6,56.7,7.2,57,6.7,57z",
+        className: "cr2"
+      }), /*#__PURE__*/_react["default"].createElement("path", {
+        d: "M56.8,56.4c-0.8,0-1.4-0.6-1.4-1.4c0-13.5-6.8-24.4-12.9-25.8c-3.5-0.8-5.6,2-6.7,4.4c-0.3,0.7-1.2,1-1.9,0.7 c-0.7-0.3-1-1.2-0.7-1.9c2.2-4.7,5.8-6.9,9.9-6c9,2,15.1,16.4,15.1,28.6C58.3,55.7,57.6,56.4,56.8,56.4z",
+        className: "cr3"
+      }), /*#__PURE__*/_react["default"].createElement("path", {
+        d: "M34.5,32.7c-0.2,0-0.3,0-0.5,0c-1.3-0.3-2.1-1.5-1.8-2.8c3.5-17.4,10.3-20.7,14-21.2c4.4-0.5,8.6,2.3,11,7.4 c0.6,1.2,0,2.6-1.1,3.1c-1.2,0.6-2.6,0-3.1-1.1c-1.5-3.2-3.8-5-6.1-4.7c-1.5,0.2-6.8,2-9.9,17.4C36.6,32,35.6,32.7,34.5,32.7z",
+        className: "cr4"
+      }));
+    }
+  }]);
+  return ArcLayerIcon;
+}(_react.Component);
+
+(0, _defineProperty2["default"])(ArcLayerIcon, "propTypes", {
+  /** Set the height of the icon, ex. '16px' */
+  height: _propTypes["default"].string,
+  colors: _propTypes["default"].arrayOf(_propTypes["default"].string)
+});
+(0, _defineProperty2["default"])(ArcLayerIcon, "defaultProps", {
+  height: '16px',
+  predefinedClassName: 'point-layer-icon',
+  totalColor: 4
+});
+var _default = ArcLayerIcon;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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