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

package/dist/layers/heatmap-layer/heatmap-layer.js

@@ -0,0 +1,269 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.heatmapVisConfigs = exports.pointColResolver = exports.pointPosAccessor = exports.MAX_ZOOM_LEVEL = void 0;
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _reselect = require("reselect");
+
+var _lodash = _interopRequireDefault(require("lodash.memoize"));
+
+var _defaultSettings = require("../../constants/default-settings");
+
+var _colorUtils = require("../../utils/color-utils");
+
+var _mapboxglLayer = _interopRequireDefault(require("../mapboxgl-layer"));
+
+var _heatmapLayerIcon = _interopRequireDefault(require("./heatmap-layer-icon"));
+
+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 MAX_ZOOM_LEVEL = 18;
+exports.MAX_ZOOM_LEVEL = MAX_ZOOM_LEVEL;
+
+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 pointColResolver = function pointColResolver(_ref2) {
+  var lat = _ref2.lat,
+      lng = _ref2.lng;
+  return "".concat(lat.fieldIdx, "-").concat(lng.fieldIdx);
+};
+
+exports.pointColResolver = pointColResolver;
+var heatmapVisConfigs = {
+  opacity: 'opacity',
+  colorRange: 'colorRange',
+  radius: 'heatmapRadius'
+};
+/**
+ *
+ * @param {Object} colorRange
+ * @return {Array} [
+ *  0, "rgba(33,102,172,0)",
+ *  0.2, "rgb(103,169,207)",
+ *  0.4, "rgb(209,229,240)",
+ *  0.6, "rgb(253,219,199)",
+ *  0.8, "rgb(239,138,98)",
+ *  1, "rgb(178,24,43)"
+ * ]
+ */
+
+exports.heatmapVisConfigs = heatmapVisConfigs;
+
+var heatmapDensity = function heatmapDensity(colorRange) {
+  var scaleFunction = _defaultSettings.SCALE_FUNC.quantize;
+  var colors = ['#000000'].concat((0, _toConsumableArray2["default"])(colorRange.colors));
+  var scale = scaleFunction().domain([0, 1]).range(colors);
+  var colorDensity = scale.range().reduce(function (bands, level) {
+    var invert = scale.invertExtent(level);
+    return [].concat((0, _toConsumableArray2["default"])(bands), [invert[0], // first value in the range
+    "rgb(".concat((0, _colorUtils.hexToRgb)(level).join(','), ")") // color
+    ]);
+  }, []);
+  colorDensity[1] = 'rgba(0,0,0,0)';
+  return colorDensity;
+};
+
+var HeatmapLayer = /*#__PURE__*/function (_MapboxGLLayer) {
+  (0, _inherits2["default"])(HeatmapLayer, _MapboxGLLayer);
+
+  var _super = _createSuper(HeatmapLayer);
+
+  function HeatmapLayer(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, HeatmapLayer);
+    _this = _super.call(this, props);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "columnsSelector", function (config) {
+      return pointColResolver(config.columns);
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "visConfigSelector", function (config) {
+      return config.visConfig;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "weightFieldSelector", function (config) {
+      return config.weightField ? config.weightField.name : null;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "weightDomainSelector", function (config) {
+      return config.weightDomain;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "paintSelector", (0, _reselect.createSelector)(_this.visConfigSelector, _this.weightFieldSelector, _this.weightDomainSelector, function (visConfig, weightField, weightDomain) {
+      return {
+        'heatmap-weight': weightField ? ['interpolate', ['linear'], ['get', weightField], weightDomain[0], 0, weightDomain[1], 1] : 1,
+        'heatmap-intensity': ['interpolate', ['linear'], ['zoom'], 0, 1, MAX_ZOOM_LEVEL, 3],
+        'heatmap-color': ['interpolate', ['linear'], ['heatmap-density']].concat((0, _toConsumableArray2["default"])(heatmapDensity(visConfig.colorRange))),
+        'heatmap-radius': ['interpolate', ['linear'], ['zoom'], 0, 2, MAX_ZOOM_LEVEL, visConfig.radius // radius
+        ],
+        'heatmap-opacity': visConfig.opacity
+      };
+    }));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "computeHeatmapConfiguration", (0, _reselect.createSelector)(_this.sourceSelector, _this.filterSelector, _this.paintSelector, function (source, filter, paint) {
+      return _objectSpread({
+        type: 'heatmap',
+        id: _this.id,
+        source: source,
+        layout: {
+          visibility: 'visible'
+        },
+        maxzoom: MAX_ZOOM_LEVEL,
+        paint: paint
+      }, _this.isValidFilter(filter) ? {
+        filter: filter
+      } : {});
+    }));
+
+    _this.registerVisConfig(heatmapVisConfigs);
+
+    _this.getPosition = (0, _lodash["default"])(pointPosAccessor, pointColResolver);
+    return _this;
+  }
+
+  (0, _createClass2["default"])(HeatmapLayer, [{
+    key: "type",
+    get: function get() {
+      return 'heatmap';
+    }
+  }, {
+    key: "visualChannels",
+    get: function get() {
+      return {
+        weight: {
+          property: 'weight',
+          field: 'weightField',
+          scale: 'weightScale',
+          domain: 'weightDomain',
+          key: 'weight',
+          // supportedFieldTypes can be determined by channelScaleType
+          // or specified here
+          defaultMeasure: 'property.density',
+          supportedFieldTypes: [_defaultSettings.ALL_FIELD_TYPES.real, _defaultSettings.ALL_FIELD_TYPES.integer],
+          channelScaleType: _defaultSettings.CHANNEL_SCALES.size
+        }
+      };
+    }
+  }, {
+    key: "layerIcon",
+    get: function get() {
+      return _heatmapLayerIcon["default"];
+    }
+  }, {
+    key: "getVisualChannelDescription",
+    value: function getVisualChannelDescription(channel) {
+      return channel === 'color' ? {
+        label: 'property.color',
+        measure: 'property.density'
+      } : {
+        label: 'property.weight',
+        measure: this.config.weightField ? this.config.weightField.name : 'property.density'
+      };
+    }
+  }, {
+    key: "getDefaultLayerConfig",
+    value: function getDefaultLayerConfig() {
+      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      // mapbox heatmap layer color is always based on density
+      // no need to set colorField, colorDomain and colorScale
+
+      /* eslint-disable no-unused-vars */
+      var _get$call$weightField = _objectSpread(_objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(HeatmapLayer.prototype), "getDefaultLayerConfig", this).call(this, props)), {}, {
+        weightField: null,
+        weightDomain: [0, 1],
+        weightScale: 'linear'
+      }),
+          colorField = _get$call$weightField.colorField,
+          colorDomain = _get$call$weightField.colorDomain,
+          colorScale = _get$call$weightField.colorScale,
+          layerConfig = (0, _objectWithoutProperties2["default"])(_get$call$weightField, ["colorField", "colorDomain", "colorScale"]);
+      /* eslint-enable no-unused-vars */
+
+
+      return layerConfig;
+    }
+  }, {
+    key: "getPositionAccessor",
+    value: function getPositionAccessor(dataContainer) {
+      return this.getPosition(this.config.columns)(dataContainer);
+    }
+  }, {
+    key: "updateLayerMeta",
+    value: function updateLayerMeta(dataContainer) {
+      var getPosition = this.getPositionAccessor(dataContainer);
+      var bounds = this.getPointsBounds(dataContainer, getPosition);
+      this.updateMeta({
+        bounds: bounds
+      });
+    }
+  }, {
+    key: "getGeometry",
+    value: function getGeometry(position) {
+      return position.every(Number.isFinite) ? {
+        type: 'Point',
+        coordinates: position
+      } : null;
+    }
+  }, {
+    key: "formatLayerData",
+    value: function formatLayerData(datasets, oldLayerData) {
+      var weightField = this.config.weightField;
+      var dataContainer = datasets[this.config.dataId].dataContainer;
+      var getPosition = this.getPositionAccessor(dataContainer);
+
+      var _this$updateData = this.updateData(datasets, oldLayerData),
+          data = _this$updateData.data;
+
+      var newConfig = this.computeHeatmapConfiguration(this.config, datasets);
+      newConfig.id = this.id;
+      return {
+        columns: this.config.columns,
+        config: newConfig,
+        data: data,
+        weightField: weightField,
+        getPosition: getPosition
+      };
+    }
+  }]);
+  return HeatmapLayer;
+}(_mapboxglLayer["default"]);
+
+var _default = HeatmapLayer;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/layers/heatmap-layer/heatmap-layer.js"],"names":["MAX_ZOOM_LEVEL","pointPosAccessor","lat","lng","dc","d","valueAt","index","fieldIdx","pointColResolver","heatmapVisConfigs","opacity","colorRange","radius","heatmapDensity","scaleFunction","SCALE_FUNC","quantize","colors","scale","domain","range","colorDensity","reduce","bands","level","invert","invertExtent","join","HeatmapLayer","props","config","columns","visConfig","weightField","name","weightDomain","visConfigSelector","weightFieldSelector","weightDomainSelector","sourceSelector","filterSelector","paintSelector","source","filter","paint","type","id","layout","visibility","maxzoom","isValidFilter","registerVisConfig","getPosition","weight","property","field","key","defaultMeasure","supportedFieldTypes","ALL_FIELD_TYPES","real","integer","channelScaleType","CHANNEL_SCALES","size","HeatmapLayerIcon","channel","label","measure","weightScale","colorField","colorDomain","colorScale","layerConfig","dataContainer","getPositionAccessor","bounds","getPointsBounds","updateMeta","position","every","Number","isFinite","coordinates","datasets","oldLayerData","dataId","updateData","data","newConfig","computeHeatmapConfiguration","MapboxGLLayer"],"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 {createSelector} from 'reselect';\nimport memoize from 'lodash.memoize';\nimport {CHANNEL_SCALES, SCALE_FUNC, ALL_FIELD_TYPES} from 'constants/default-settings';\nimport {hexToRgb} from 'utils/color-utils';\nimport MapboxGLLayer from '../mapboxgl-layer';\nimport HeatmapLayerIcon from './heatmap-layer-icon';\n\nexport const MAX_ZOOM_LEVEL = 18;\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 pointColResolver = ({lat, lng}) => `${lat.fieldIdx}-${lng.fieldIdx}`;\n\nexport const heatmapVisConfigs = {\n  opacity: 'opacity',\n  colorRange: 'colorRange',\n  radius: 'heatmapRadius'\n};\n\n/**\n *\n * @param {Object} colorRange\n * @return {Array} [\n *  0, \"rgba(33,102,172,0)\",\n *  0.2, \"rgb(103,169,207)\",\n *  0.4, \"rgb(209,229,240)\",\n *  0.6, \"rgb(253,219,199)\",\n *  0.8, \"rgb(239,138,98)\",\n *  1, \"rgb(178,24,43)\"\n * ]\n */\nconst heatmapDensity = colorRange => {\n  const scaleFunction = SCALE_FUNC.quantize;\n\n  const colors = ['#000000', ...colorRange.colors];\n\n  const scale = scaleFunction()\n    .domain([0, 1])\n    .range(colors);\n\n  const colorDensity = scale.range().reduce((bands, level) => {\n    const invert = scale.invertExtent(level);\n    return [\n      ...bands,\n      invert[0], // first value in the range\n      `rgb(${hexToRgb(level).join(',')})` // color\n    ];\n  }, []);\n  colorDensity[1] = 'rgba(0,0,0,0)';\n  return colorDensity;\n};\n\nclass HeatmapLayer extends MapboxGLLayer {\n  constructor(props) {\n    super(props);\n    this.registerVisConfig(heatmapVisConfigs);\n    this.getPosition = memoize(pointPosAccessor, pointColResolver);\n  }\n\n  get type() {\n    return 'heatmap';\n  }\n\n  get visualChannels() {\n    return {\n      weight: {\n        property: 'weight',\n        field: 'weightField',\n        scale: 'weightScale',\n        domain: 'weightDomain',\n        key: 'weight',\n        // supportedFieldTypes can be determined by channelScaleType\n        // or specified here\n        defaultMeasure: 'property.density',\n        supportedFieldTypes: [ALL_FIELD_TYPES.real, ALL_FIELD_TYPES.integer],\n        channelScaleType: CHANNEL_SCALES.size\n      }\n    };\n  }\n\n  get layerIcon() {\n    return HeatmapLayerIcon;\n  }\n\n  getVisualChannelDescription(channel) {\n    return channel === 'color'\n      ? {\n          label: 'property.color',\n          measure: 'property.density'\n        }\n      : {\n          label: 'property.weight',\n          measure: this.config.weightField ? this.config.weightField.name : 'property.density'\n        };\n  }\n\n  getDefaultLayerConfig(props = {}) {\n    // mapbox heatmap layer color is always based on density\n    // no need to set colorField, colorDomain and colorScale\n    /* eslint-disable no-unused-vars */\n    const {colorField, colorDomain, colorScale, ...layerConfig} = {\n      ...super.getDefaultLayerConfig(props),\n\n      weightField: null,\n      weightDomain: [0, 1],\n      weightScale: 'linear'\n    };\n    /* eslint-enable no-unused-vars */\n\n    return layerConfig;\n  }\n\n  getPositionAccessor(dataContainer) {\n    return this.getPosition(this.config.columns)(dataContainer);\n  }\n\n  updateLayerMeta(dataContainer) {\n    const getPosition = this.getPositionAccessor(dataContainer);\n    const bounds = this.getPointsBounds(dataContainer, getPosition);\n    this.updateMeta({bounds});\n  }\n\n  columnsSelector = config => pointColResolver(config.columns);\n  visConfigSelector = config => config.visConfig;\n  weightFieldSelector = config => (config.weightField ? config.weightField.name : null);\n  weightDomainSelector = config => config.weightDomain;\n\n  paintSelector = createSelector(\n    this.visConfigSelector,\n    this.weightFieldSelector,\n    this.weightDomainSelector,\n    (visConfig, weightField, weightDomain) => ({\n      'heatmap-weight': weightField\n        ? ['interpolate', ['linear'], ['get', weightField], weightDomain[0], 0, weightDomain[1], 1]\n        : 1,\n      'heatmap-intensity': ['interpolate', ['linear'], ['zoom'], 0, 1, MAX_ZOOM_LEVEL, 3],\n      'heatmap-color': [\n        'interpolate',\n        ['linear'],\n        ['heatmap-density'],\n        ...heatmapDensity(visConfig.colorRange)\n      ],\n      'heatmap-radius': [\n        'interpolate',\n        ['linear'],\n        ['zoom'],\n        0,\n        2,\n        MAX_ZOOM_LEVEL,\n        visConfig.radius // radius\n      ],\n      'heatmap-opacity': visConfig.opacity\n    })\n  );\n\n  computeHeatmapConfiguration = createSelector(\n    this.sourceSelector,\n    this.filterSelector,\n    this.paintSelector,\n    (source, filter, paint) => {\n      return {\n        type: 'heatmap',\n        id: this.id,\n        source,\n        layout: {\n          visibility: 'visible'\n        },\n        maxzoom: MAX_ZOOM_LEVEL,\n        paint,\n        ...(this.isValidFilter(filter) ? {filter} : {})\n      };\n    }\n  );\n\n  getGeometry(position) {\n    return position.every(Number.isFinite)\n      ? {\n          type: 'Point',\n          coordinates: position\n        }\n      : null;\n  }\n\n  formatLayerData(datasets, oldLayerData) {\n    const {weightField} = this.config;\n    const {dataContainer} = datasets[this.config.dataId];\n    const getPosition = this.getPositionAccessor(dataContainer);\n    const {data} = this.updateData(datasets, oldLayerData);\n\n    const newConfig = this.computeHeatmapConfiguration(this.config, datasets);\n    newConfig.id = this.id;\n\n    return {\n      columns: this.config.columns,\n      config: newConfig,\n      data,\n      weightField,\n      getPosition\n    };\n  }\n}\n\nexport default HeatmapLayer;\n"]}

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

@@ -0,0 +1,100 @@
+"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 HexagonLayerIcon = /*#__PURE__*/function (_Component) {
+  (0, _inherits2["default"])(HexagonLayerIcon, _Component);
+
+  var _super = _createSuper(HexagonLayerIcon);
+
+  function HexagonLayerIcon() {
+    (0, _classCallCheck2["default"])(this, HexagonLayerIcon);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(HexagonLayerIcon, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/_react["default"].createElement(_base["default"], this.props, /*#__PURE__*/_react["default"].createElement("polygon", {
+        className: "cr1",
+        points: "23.9,10 30.9,14 30.9,22.1 23.9,26.2 16.8,22.1 16.8,14 ",
+        style: {
+          opacity: 0.6
+        }
+      }), /*#__PURE__*/_react["default"].createElement("polygon", {
+        className: "cr2",
+        points: "23.9,37.8 30.9,41.9 30.9,50 23.9,54 16.8,50 16.8,41.9 ",
+        style: {
+          opacity: 0.4
+        }
+      }), /*#__PURE__*/_react["default"].createElement("polygon", {
+        className: "cr6",
+        points: "40.1,10 47.2,14 47.2,22.1 40.1,26.2 33.1,22.1 33.1,14 "
+      }), /*#__PURE__*/_react["default"].createElement("polygon", {
+        className: "cr3",
+        points: "40.1,37.8 47.2,41.9 47.2,50 40.1,54 33.1,50 33.1,41.9 ",
+        style: {
+          opacity: 0.8
+        }
+      }), /*#__PURE__*/_react["default"].createElement("polygon", {
+        className: "cr1",
+        points: "15.8,23.9 22.8,27.9 22.8,36.1 15.8,40.1 8.7,36.1 8.7,27.9 "
+      }), /*#__PURE__*/_react["default"].createElement("polygon", {
+        className: "cr4",
+        points: "32,23.9 39,27.9 39,36.1 32,40.1 25,36.1 25,27.9 ",
+        style: {
+          opacity: 0.8
+        }
+      }), /*#__PURE__*/_react["default"].createElement("polygon", {
+        className: "cr5",
+        points: "48.2,23.9 55.3,27.9 55.3,36.1 48.2,40.1 41.2,36.1 41.2,27.9 ",
+        style: {
+          opacity: 0.4
+        }
+      }));
+    }
+  }]);
+  return HexagonLayerIcon;
+}(_react.Component);
+
+exports["default"] = HexagonLayerIcon;
+(0, _defineProperty2["default"])(HexagonLayerIcon, "propTypes", {
+  /** Set the height of the icon, ex. '16px' */
+  height: _propTypes["default"].string,
+  colors: _propTypes["default"].arrayOf(_propTypes["default"].string)
+});
+(0, _defineProperty2["default"])(HexagonLayerIcon, "defaultProps", {
+  height: '16px',
+  predefinedClassName: 'hexagon-layer-icon',
+  totalColor: 6
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/layers/hexagon-layer/hexagon-layer.js

@@ -0,0 +1,120 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.hexagonVisConfigs = 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 _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _layers = require("@deck.gl/layers");
+
+var _aggregationLayer = _interopRequireDefault(require("../aggregation-layer"));
+
+var _enhancedHexagonLayer = _interopRequireDefault(require("../../deckgl-layers/hexagon-layer/enhanced-hexagon-layer"));
+
+var _hexagonUtils = require("./hexagon-utils");
+
+var _hexagonLayerIcon = _interopRequireDefault(require("./hexagon-layer-icon"));
+
+var _dataUtils = require("../../utils/data-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 _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 hexagonVisConfigs = {
+  opacity: 'opacity',
+  worldUnitSize: 'worldUnitSize',
+  resolution: 'resolution',
+  colorRange: 'colorRange',
+  coverage: 'coverage',
+  sizeRange: 'elevationRange',
+  percentile: 'percentile',
+  elevationPercentile: 'elevationPercentile',
+  elevationScale: 'elevationScale',
+  enableElevationZoomFactor: 'enableElevationZoomFactor',
+  colorAggregation: 'aggregation',
+  sizeAggregation: 'sizeAggregation',
+  enable3d: 'enable3d'
+};
+exports.hexagonVisConfigs = hexagonVisConfigs;
+
+var HexagonLayer = /*#__PURE__*/function (_AggregationLayer) {
+  (0, _inherits2["default"])(HexagonLayer, _AggregationLayer);
+
+  var _super = _createSuper(HexagonLayer);
+
+  function HexagonLayer(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, HexagonLayer);
+    _this = _super.call(this, props);
+
+    _this.registerVisConfig(hexagonVisConfigs);
+
+    _this.visConfigSettings.worldUnitSize.label = 'columns.hexagon.worldUnitSize';
+    return _this;
+  }
+
+  (0, _createClass2["default"])(HexagonLayer, [{
+    key: "type",
+    get: function get() {
+      return 'hexagon';
+    }
+  }, {
+    key: "name",
+    get: function get() {
+      return 'Hexbin';
+    }
+  }, {
+    key: "layerIcon",
+    get: function get() {
+      return _hexagonLayerIcon["default"];
+    }
+  }, {
+    key: "renderLayer",
+    value: function renderLayer(opts) {
+      var data = opts.data,
+          objectHovered = opts.objectHovered,
+          mapState = opts.mapState;
+      var zoomFactor = this.getZoomFactor(mapState);
+      var visConfig = this.config.visConfig;
+      var radius = visConfig.worldUnitSize * 1000;
+      var hoveredObject = this.hasHoveredObject(objectHovered);
+      return [new _enhancedHexagonLayer["default"](_objectSpread(_objectSpread(_objectSpread({}, this.getDefaultAggregationLayerProp(opts)), data), {}, {
+        wrapLongitude: false,
+        radius: radius
+      }))].concat((0, _toConsumableArray2["default"])(hoveredObject && !visConfig.enable3d ? [new _layers.GeoJsonLayer(_objectSpread(_objectSpread({}, this.getDefaultHoverLayerProps()), {}, {
+        wrapLongitude: false,
+        data: [(0, _hexagonUtils.hexagonToPolygonGeo)(hoveredObject, {}, radius * visConfig.coverage, mapState)].filter(function (d) {
+          return d;
+        }),
+        getLineColor: this.config.highlightColor,
+        lineWidthScale: (0, _dataUtils.clamp)([1, 100], radius * 0.1 * zoomFactor)
+      }))] : []));
+    }
+  }]);
+  return HexagonLayer;
+}(_aggregationLayer["default"]);
+
+exports["default"] = HexagonLayer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/layers/hexagon-layer/hexagon-utils.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hexagonToPolygonGeo = hexagonToPolygonGeo;
+
+var _core = require("@deck.gl/core");
+
+var _console = _interopRequireDefault(require("global/console"));
+
+// 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.
+function hexagonToPolygonGeo(object, properties, radius, mapState) {
+  var viewport = new _core.WebMercatorViewport(mapState);
+
+  if (!Array.isArray(object.position)) {
+    return null;
+  }
+
+  var screenCenter = viewport.projectFlat(object.position);
+
+  var _viewport$getDistance = viewport.getDistanceScales(object.position),
+      unitsPerMeter = _viewport$getDistance.unitsPerMeter;
+
+  if (!Array.isArray(unitsPerMeter)) {
+    _console["default"].warn("unitsPerMeter is undefined");
+
+    return null;
+  }
+
+  var pixRadius = radius * unitsPerMeter[0];
+  var coordinates = [];
+
+  for (var i = 0; i < 6; i++) {
+    var vertex = hex_corner(screenCenter, pixRadius, i);
+    coordinates.push(viewport.unprojectFlat(vertex));
+  }
+
+  coordinates.push(coordinates[0]);
+  return {
+    geometry: {
+      coordinates: coordinates,
+      type: 'LineString'
+    },
+    properties: properties
+  };
+}
+
+function hex_corner(center, radius, i) {
+  var angle_deg = 60 * i + 30;
+  var angle_rad = Math.PI / 180 * angle_deg;
+  return [center[0] + radius * Math.cos(angle_rad), center[1] + radius * Math.sin(angle_rad)];
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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