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

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

@@ -0,0 +1,183 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseGeoJsonRawFeature = parseGeoJsonRawFeature;
+exports.getGeojsonDataMaps = getGeojsonDataMaps;
+exports.parseGeometryFromString = parseGeometryFromString;
+exports.getGeojsonBounds = getGeojsonBounds;
+exports.getGeojsonFeatureTypes = getGeojsonFeatureTypes;
+exports.featureToDeckGlGeoType = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _wellknown = _interopRequireDefault(require("wellknown"));
+
+var _geojsonNormalize = _interopRequireDefault(require("@mapbox/geojson-normalize"));
+
+var _bbox = _interopRequireDefault(require("@turf/bbox"));
+
+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 parseGeoJsonRawFeature(rawFeature) {
+  if ((0, _typeof2["default"])(rawFeature) === 'object') {
+    // Support GeoJson feature as object
+    // probably need to normalize it as well
+    var normalized = (0, _geojsonNormalize["default"])(rawFeature);
+
+    if (!normalized || !Array.isArray(normalized.features)) {
+      // fail to normalize GeoJson
+      return null;
+    }
+
+    return normalized.features[0];
+  } else if (typeof rawFeature === 'string') {
+    return parseGeometryFromString(rawFeature);
+  } else if (Array.isArray(rawFeature)) {
+    // Support GeoJson  LineString as an array of points
+    return {
+      type: 'Feature',
+      geometry: {
+        // why do we need to flip it...
+        coordinates: rawFeature.map(function (pts) {
+          return [pts[1], pts[0]];
+        }),
+        type: 'LineString'
+      }
+    };
+  }
+
+  return null;
+}
+/**
+ * Parse raw data to GeoJson feature
+ * @param dataContainer
+ * @param getFeature
+ * @returns {{}}
+ */
+
+
+function getGeojsonDataMaps(dataContainer, getFeature) {
+  var acceptableTypes = ['Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon', 'GeometryCollection'];
+  var dataToFeature = [];
+
+  for (var index = 0; index < dataContainer.numRows(); index++) {
+    var feature = parseGeoJsonRawFeature(getFeature({
+      index: index
+    }));
+
+    if (feature && feature.geometry && acceptableTypes.includes(feature.geometry.type)) {
+      var cleaned = _objectSpread(_objectSpread({}, feature), {}, {
+        // store index of the data in feature properties
+        properties: _objectSpread(_objectSpread({}, feature.properties), {}, {
+          index: index
+        })
+      });
+
+      dataToFeature[index] = cleaned;
+    } else {
+      dataToFeature[index] = null;
+    }
+  }
+
+  return dataToFeature;
+}
+/**
+ * Parse geojson from string
+ * @param {String} geoString
+ * @returns {null | Object} geojson object or null if failed
+ */
+
+
+function parseGeometryFromString(geoString) {
+  var parsedGeo; // try parse as geojson string
+  // {"type":"Polygon","coordinates":[[[-74.158491,40.83594]]]}
+
+  try {
+    parsedGeo = JSON.parse(geoString);
+  } catch (e) {// keep trying to parse
+  } // try parse as wkt
+
+
+  if (!parsedGeo) {
+    try {
+      parsedGeo = (0, _wellknown["default"])(geoString);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  if (!parsedGeo) {
+    return null;
+  }
+
+  var normalized = (0, _geojsonNormalize["default"])(parsedGeo);
+
+  if (!normalized || !Array.isArray(normalized.features)) {
+    // fail to normalize geojson
+    return null;
+  }
+
+  return normalized.features[0];
+}
+
+function getGeojsonBounds() {
+  var features = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  // 70 ms for 10,000 polygons
+  // here we only pick couple
+  var maxCount = 10000;
+  var samples = features.length > maxCount ? (0, _dataUtils.getSampleData)(features, maxCount) : features;
+  var nonEmpty = samples.filter(function (d) {
+    return d && d.geometry && d.geometry.coordinates && d.geometry.coordinates.length;
+  });
+
+  try {
+    return (0, _bbox["default"])({
+      type: 'FeatureCollection',
+      features: nonEmpty
+    });
+  } catch (e) {
+    return null;
+  }
+}
+
+var featureToDeckGlGeoType = {
+  Point: 'point',
+  MultiPoint: 'point',
+  LineString: 'line',
+  MultiLineString: 'line',
+  Polygon: 'polygon',
+  MultiPolygon: 'polygon'
+};
+/**
+ * Parse geojson from string
+ * @param {Array<Object>} allFeatures
+ * @returns {Object} mapping of feature type existence
+ */
+
+exports.featureToDeckGlGeoType = featureToDeckGlGeoType;
+
+function getGeojsonFeatureTypes(allFeatures) {
+  var featureTypes = {};
+
+  for (var f = 0; f < allFeatures.length; f++) {
+    var feature = allFeatures[f];
+    var geoType = featureToDeckGlGeoType[feature && feature.geometry && feature.geometry.type];
+
+    if (geoType) {
+      featureTypes[geoType] = true;
+    }
+  }
+
+  return featureTypes;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/layers/geojson-layer/geojson-utils.js"],"names":["parseGeoJsonRawFeature","rawFeature","normalized","Array","isArray","features","parseGeometryFromString","type","geometry","coordinates","map","pts","getGeojsonDataMaps","dataContainer","getFeature","acceptableTypes","dataToFeature","index","numRows","feature","includes","cleaned","properties","geoString","parsedGeo","JSON","parse","e","getGeojsonBounds","maxCount","samples","length","nonEmpty","filter","d","featureToDeckGlGeoType","Point","MultiPoint","LineString","MultiLineString","Polygon","MultiPolygon","getGeojsonFeatureTypes","allFeatures","featureTypes","f","geoType"],"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 wktParser from 'wellknown';\nimport normalize from '@mapbox/geojson-normalize';\nimport bbox from '@turf/bbox';\n\nimport {getSampleData} from 'utils/data-utils';\n\nexport function parseGeoJsonRawFeature(rawFeature) {\n  if (typeof rawFeature === 'object') {\n    // Support GeoJson feature as object\n    // probably need to normalize it as well\n    const normalized = normalize(rawFeature);\n    if (!normalized || !Array.isArray(normalized.features)) {\n      // fail to normalize GeoJson\n      return null;\n    }\n\n    return normalized.features[0];\n  } else if (typeof rawFeature === 'string') {\n    return parseGeometryFromString(rawFeature);\n  } else if (Array.isArray(rawFeature)) {\n    // Support GeoJson  LineString as an array of points\n    return {\n      type: 'Feature',\n      geometry: {\n        // why do we need to flip it...\n        coordinates: rawFeature.map(pts => [pts[1], pts[0]]),\n        type: 'LineString'\n      }\n    };\n  }\n\n  return null;\n}\n/**\n * Parse raw data to GeoJson feature\n * @param dataContainer\n * @param getFeature\n * @returns {{}}\n */\nexport function getGeojsonDataMaps(dataContainer, getFeature) {\n  const acceptableTypes = [\n    'Point',\n    'MultiPoint',\n    'LineString',\n    'MultiLineString',\n    'Polygon',\n    'MultiPolygon',\n    'GeometryCollection'\n  ];\n\n  const dataToFeature = [];\n\n  for (let index = 0; index < dataContainer.numRows(); index++) {\n    const feature = parseGeoJsonRawFeature(getFeature({index}));\n\n    if (feature && feature.geometry && acceptableTypes.includes(feature.geometry.type)) {\n      const cleaned = {\n        ...feature,\n        // store index of the data in feature properties\n        properties: {\n          ...feature.properties,\n          index\n        }\n      };\n\n      dataToFeature[index] = cleaned;\n    } else {\n      dataToFeature[index] = null;\n    }\n  }\n\n  return dataToFeature;\n}\n\n/**\n * Parse geojson from string\n * @param {String} geoString\n * @returns {null | Object} geojson object or null if failed\n */\nexport function parseGeometryFromString(geoString) {\n  let parsedGeo;\n\n  // try parse as geojson string\n  // {\"type\":\"Polygon\",\"coordinates\":[[[-74.158491,40.83594]]]}\n  try {\n    parsedGeo = JSON.parse(geoString);\n  } catch (e) {\n    // keep trying to parse\n  }\n\n  // try parse as wkt\n  if (!parsedGeo) {\n    try {\n      parsedGeo = wktParser(geoString);\n    } catch (e) {\n      return null;\n    }\n  }\n\n  if (!parsedGeo) {\n    return null;\n  }\n\n  const normalized = normalize(parsedGeo);\n\n  if (!normalized || !Array.isArray(normalized.features)) {\n    // fail to normalize geojson\n    return null;\n  }\n\n  return normalized.features[0];\n}\n\nexport function getGeojsonBounds(features = []) {\n  // 70 ms for 10,000 polygons\n  // here we only pick couple\n  const maxCount = 10000;\n  const samples = features.length > maxCount ? getSampleData(features, maxCount) : features;\n\n  const nonEmpty = samples.filter(\n    d => d && d.geometry && d.geometry.coordinates && d.geometry.coordinates.length\n  );\n\n  try {\n    return bbox({\n      type: 'FeatureCollection',\n      features: nonEmpty\n    });\n  } catch (e) {\n    return null;\n  }\n}\n\nexport const featureToDeckGlGeoType = {\n  Point: 'point',\n  MultiPoint: 'point',\n  LineString: 'line',\n  MultiLineString: 'line',\n  Polygon: 'polygon',\n  MultiPolygon: 'polygon'\n};\n\n/**\n * Parse geojson from string\n * @param {Array<Object>} allFeatures\n * @returns {Object} mapping of feature type existence\n */\nexport function getGeojsonFeatureTypes(allFeatures) {\n  const featureTypes = {};\n  for (let f = 0; f < allFeatures.length; f++) {\n    const feature = allFeatures[f];\n    const geoType = featureToDeckGlGeoType[feature && feature.geometry && feature.geometry.type];\n    if (geoType) {\n      featureTypes[geoType] = true;\n    }\n  }\n\n  return featureTypes;\n}\n"]}

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

@@ -0,0 +1,136 @@
+"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 GridLayerIcon = /*#__PURE__*/function (_Component) {
+  (0, _inherits2["default"])(GridLayerIcon, _Component);
+
+  var _super = _createSuper(GridLayerIcon);
+
+  function GridLayerIcon() {
+    (0, _classCallCheck2["default"])(this, GridLayerIcon);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(GridLayerIcon, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/_react["default"].createElement(_base["default"], this.props, /*#__PURE__*/_react["default"].createElement("rect", {
+        x: "11.2",
+        y: "11.2",
+        className: "cr1",
+        width: "13.1",
+        height: "13.1",
+        style: {
+          opacity: 0.8
+        }
+      }), /*#__PURE__*/_react["default"].createElement("rect", {
+        x: "25.4",
+        y: "11.2",
+        className: "cr2",
+        width: "13.1",
+        height: "13.1",
+        style: {
+          opacity: 0.8
+        }
+      }), /*#__PURE__*/_react["default"].createElement("rect", {
+        x: "39.6",
+        y: "11.2",
+        width: "13.1",
+        height: "13.1",
+        className: "cr3"
+      }), /*#__PURE__*/_react["default"].createElement("rect", {
+        x: "11.2",
+        y: "25.4",
+        className: "cr4",
+        width: "13.1",
+        height: "13.1",
+        style: {
+          opacity: 0.4
+        }
+      }), /*#__PURE__*/_react["default"].createElement("rect", {
+        x: "25.4",
+        y: "25.4",
+        className: "cr5",
+        width: "13.1",
+        height: "13.1"
+      }), /*#__PURE__*/_react["default"].createElement("rect", {
+        x: "39.6",
+        y: "25.4",
+        className: "cr6",
+        width: "13.1",
+        height: "13.1",
+        style: {
+          opacity: 0.8
+        }
+      }), /*#__PURE__*/_react["default"].createElement("rect", {
+        x: "11.2",
+        y: "39.6",
+        width: "13.1",
+        className: "cr1",
+        height: "13.1"
+      }), /*#__PURE__*/_react["default"].createElement("rect", {
+        x: "25.4",
+        y: "39.6",
+        className: "cr2",
+        width: "13.1",
+        height: "13.1",
+        style: {
+          opacity: 0.4
+        }
+      }), /*#__PURE__*/_react["default"].createElement("rect", {
+        x: "39.6",
+        y: "39.6",
+        className: "cr3",
+        width: "13.1",
+        height: "13.1",
+        style: {
+          opacity: 0.4
+        }
+      }));
+    }
+  }]);
+  return GridLayerIcon;
+}(_react.Component);
+
+exports["default"] = GridLayerIcon;
+(0, _defineProperty2["default"])(GridLayerIcon, "propTypes", {
+  /** Set the height of the icon, ex. '16px' */
+  height: _propTypes["default"].string,
+  colors: _propTypes["default"].arrayOf(_propTypes["default"].string)
+});
+(0, _defineProperty2["default"])(GridLayerIcon, "defaultProps", {
+  height: '16px',
+  predefinedClassName: 'grid-layer-icon',
+  totalColor: 6
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,115 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.gridVisConfigs = 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 _enhancedCpuGridLayer = _interopRequireDefault(require("../../deckgl-layers/grid-layer/enhanced-cpu-grid-layer"));
+
+var _aggregationLayer = _interopRequireDefault(require("../aggregation-layer"));
+
+var _gridUtils = require("./grid-utils");
+
+var _gridLayerIcon = _interopRequireDefault(require("./grid-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 gridVisConfigs = {
+  opacity: 'opacity',
+  worldUnitSize: 'worldUnitSize',
+  colorRange: 'colorRange',
+  coverage: 'coverage',
+  sizeRange: 'elevationRange',
+  percentile: 'percentile',
+  elevationPercentile: 'elevationPercentile',
+  elevationScale: 'elevationScale',
+  enableElevationZoomFactor: 'enableElevationZoomFactor',
+  colorAggregation: 'aggregation',
+  sizeAggregation: 'sizeAggregation',
+  enable3d: 'enable3d'
+};
+exports.gridVisConfigs = gridVisConfigs;
+
+var GridLayer = /*#__PURE__*/function (_AggregationLayer) {
+  (0, _inherits2["default"])(GridLayer, _AggregationLayer);
+
+  var _super = _createSuper(GridLayer);
+
+  function GridLayer(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, GridLayer);
+    _this = _super.call(this, props);
+
+    _this.registerVisConfig(gridVisConfigs);
+
+    _this.visConfigSettings.worldUnitSize.label = 'columns.grid.worldUnitSize';
+    return _this;
+  }
+
+  (0, _createClass2["default"])(GridLayer, [{
+    key: "type",
+    get: function get() {
+      return 'grid';
+    }
+  }, {
+    key: "layerIcon",
+    get: function get() {
+      return _gridLayerIcon["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 cellSize = visConfig.worldUnitSize * 1000;
+      var hoveredObject = this.hasHoveredObject(objectHovered);
+      return [new _enhancedCpuGridLayer["default"](_objectSpread(_objectSpread(_objectSpread({}, this.getDefaultAggregationLayerProp(opts)), data), {}, {
+        wrapLongitude: false,
+        cellSize: cellSize
+      }))].concat((0, _toConsumableArray2["default"])(hoveredObject && !visConfig.enable3d ? [new _layers.GeoJsonLayer(_objectSpread(_objectSpread({}, this.getDefaultHoverLayerProps()), {}, {
+        wrapLongitude: false,
+        data: [(0, _gridUtils.pointToPolygonGeo)({
+          object: hoveredObject,
+          cellSize: cellSize,
+          coverage: visConfig.coverage,
+          mapState: mapState
+        })],
+        getLineColor: this.config.highlightColor,
+        lineWidthScale: 8 * zoomFactor
+      }))] : []));
+    }
+  }]);
+  return GridLayer;
+}(_aggregationLayer["default"]);
+
+exports["default"] = GridLayer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pointToPolygonGeo = pointToPolygonGeo;
+
+var _core = require("@deck.gl/core");
+
+// 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.
+
+/**
+ * top left of the grid to a square polygon for the hover layer
+ * and current latitude
+ * @param {object} object
+ * @param {number} cellSize
+ * @param {number} coverage
+ * @param {object} properties
+ * @param {object} mapState
+ * @returns {object} - geojson feature
+ */
+// TODO: TEST
+function pointToPolygonGeo(_ref) {
+  var object = _ref.object,
+      cellSize = _ref.cellSize,
+      coverage = _ref.coverage,
+      properties = _ref.properties,
+      mapState = _ref.mapState;
+  var position = object.position;
+  var viewport = new _core.WebMercatorViewport(mapState);
+
+  if (!position) {
+    return null;
+  }
+
+  return {
+    geometry: {
+      coordinates: [viewport.addMetersToLngLat(position, [cellSize * (0.5 - coverage / 2), cellSize * (0.5 - coverage / 2)]), viewport.addMetersToLngLat(position, [cellSize * (0.5 + coverage / 2), cellSize * (0.5 - coverage / 2)]), viewport.addMetersToLngLat(position, [cellSize * (0.5 + coverage / 2), cellSize * (0.5 + coverage / 2)]), viewport.addMetersToLngLat(position, [cellSize * (0.5 - coverage / 2), cellSize * (0.5 + coverage / 2)]), viewport.addMetersToLngLat(position, [cellSize * (0.5 - coverage / 2), cellSize * (0.5 - coverage / 2)])],
+      type: 'LineString'
+    },
+    properties: properties
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,71 @@
+"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 H3HexagonLayerIcon = /*#__PURE__*/function (_Component) {
+  (0, _inherits2["default"])(H3HexagonLayerIcon, _Component);
+
+  var _super = _createSuper(H3HexagonLayerIcon);
+
+  function H3HexagonLayerIcon() {
+    (0, _classCallCheck2["default"])(this, H3HexagonLayerIcon);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(H3HexagonLayerIcon, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/_react["default"].createElement(_base["default"], this.props, /*#__PURE__*/_react["default"].createElement("path", {
+        d: "M44.59,54.5H19.41L6.81,32.68,19.41,10.87H44.59L57.19,32.68Zm-23-3.83H42.38l10.38-18-10.38-18H21.62l-10.38,18Z"
+      }), /*#__PURE__*/_react["default"].createElement("polygon", {
+        points: "24.65 32.86 24.65 37.79 22.53 37.79 22.53 26.3 24.65 26.3 24.65 30.91 29.32 30.91 29.32 26.3 31.43 26.3 31.43 37.79 29.32 37.79 29.32 32.86 24.65 32.86"
+      }), /*#__PURE__*/_react["default"].createElement("path", {
+        d: "M33.79,37.05l.6-1.67a5.86,5.86,0,0,0,1.39.61,5.59,5.59,0,0,0,1.5.19A2.57,2.57,0,0,0,39,35.66a1.81,1.81,0,0,0,.61-1.46A1.29,1.29,0,0,0,38.94,33a4.55,4.55,0,0,0-2.05-.32H35.74V31h1.1A5.4,5.4,0,0,0,38,30.85a2.1,2.1,0,0,0,.77-.29,1.53,1.53,0,0,0,.51-.54,1.58,1.58,0,0,0,.15-.73,1.14,1.14,0,0,0-.51-1,2.67,2.67,0,0,0-1.5-.34,4.56,4.56,0,0,0-1.51.24,5,5,0,0,0-1.34.73l-.7-1.61a4.92,4.92,0,0,1,1.66-.83,6.91,6.91,0,0,1,2-.31,4.41,4.41,0,0,1,2.81.79,2.71,2.71,0,0,1,1,2.24,2.33,2.33,0,0,1-.54,1.62,3.45,3.45,0,0,1-1.46.93v0a3,3,0,0,1,1.67.81,2.3,2.3,0,0,1,.64,1.7A3.27,3.27,0,0,1,40.48,37a5,5,0,0,1-3.16.91A6.77,6.77,0,0,1,33.79,37.05Z"
+      }));
+    }
+  }]);
+  return H3HexagonLayerIcon;
+}(_react.Component);
+
+(0, _defineProperty2["default"])(H3HexagonLayerIcon, "propTypes", {
+  /** Set the height of the icon, ex. '16px' */
+  height: _propTypes["default"].string,
+  colors: _propTypes["default"].arrayOf(_propTypes["default"].string)
+});
+(0, _defineProperty2["default"])(H3HexagonLayerIcon, "defaultProps", {
+  height: '16px',
+  predefinedClassName: 'h3-hexagon-layer-icon',
+  totalColor: 4
+});
+var _default = H3HexagonLayerIcon;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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