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

package/dist/3d-building-layer/3d-building-layer.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="deck.gl" />
+/// <reference types="@danmarshall/deckgl-typings/deck.gl__layers" />
+/// <reference types="@danmarshall/deckgl-typings/deck.gl__geo-layers" />
+import { CompositeLayer } from '@deck.gl/core';
+import { TileLayer as DeckGLTileLayer } from '@deck.gl/geo-layers';
+import { ThreeDBuildingLayerProps, TileDataItem } from './types';
+import { SolidPolygonLayer } from '@deck.gl/layers';
+export default class ThreeDBuildingLayer extends CompositeLayer<{}, ThreeDBuildingLayerProps> {
+    renderSubLayers(props: ThreeDBuildingLayerProps): SolidPolygonLayer<TileDataItem, import("@deck.gl/layers").SolidPolygonLayerProps<TileDataItem>>;
+    renderLayers(): DeckGLTileLayer<TileDataItem, import("@deck.gl/geo-layers/tile-layer/tile-layer").TileLayerProps<TileDataItem>>[];
+}

package/dist/3d-building-layer/3d-building-layer.js

@@ -0,0 +1,109 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _core = require("@deck.gl/core");
+
+var _geoLayers = require("@deck.gl/geo-layers");
+
+var _dBuildingUtils = require("./3d-building-utils");
+
+var _layers = require("@deck.gl/layers");
+
+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 ThreeDBuildingLayer = /*#__PURE__*/function (_CompositeLayer) {
+  (0, _inherits2["default"])(ThreeDBuildingLayer, _CompositeLayer);
+
+  var _super = _createSuper(ThreeDBuildingLayer);
+
+  function ThreeDBuildingLayer() {
+    (0, _classCallCheck2["default"])(this, ThreeDBuildingLayer);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(ThreeDBuildingLayer, [{
+    key: "renderSubLayers",
+    value: // this layer add its subLayers to the redux store, and push sample data
+    function renderSubLayers(props) {
+      return new _layers.SolidPolygonLayer(_objectSpread(_objectSpread({}, props), {}, {
+        parameters: {
+          blendFunc: ['SRC_ALPHA', 'ONE_MINUS_SRC_ALPHA', 'ONE', 'ONE_MINUS_SRC_ALPHA'],
+          blendEquation: ['FUNC_ADD', 'FUNC_ADD']
+        },
+        extruded: true,
+        opacity: 1,
+        filled: true,
+        getElevation: function getElevation(feature) {
+          return feature.properties.height || 0;
+        },
+        getPolygon: function getPolygon(feature) {
+          return feature.coordinates;
+        },
+        getFillColor: this.props.threeDBuildingColor
+      }));
+    }
+  }, {
+    key: "renderLayers",
+    value: function renderLayers() {
+      var _this = this;
+
+      return [new _geoLayers.TileLayer({
+        id: "".concat(this.id, "-deck-3d-building"),
+        getTileData: function getTileData(args) {
+          return (0, _dBuildingUtils.getTileData)(_this.props.mapboxApiUrl, _this.props.mapboxApiAccessToken, args);
+        },
+        minZoom: 13,
+        renderSubLayers: this.renderSubLayers.bind(this),
+        updateTriggers: this.props.updateTriggers
+      })];
+    }
+  }]);
+  return ThreeDBuildingLayer;
+}(_core.CompositeLayer);
+
+exports["default"] = ThreeDBuildingLayer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/3d-building-layer/3d-building-utils.d.ts

@@ -0,0 +1,7 @@
+import { Coordinates, FlatFigure, TileDataItem, VectorTileFeature, VectorTileFeatureProperties } from './types';
+export declare function getTileData(host: string, token: string, { x, y, z }: Coordinates): Promise<TileDataItem[]>;
+export declare function decodeTile(x: number, y: number, z: number, arrayBuffer: ArrayBuffer): TileDataItem[];
+export declare function vectorTileFeatureToProp(vectorTileFeature: VectorTileFeature, project: (r: FlatFigure, n: number) => void): {
+    coordinates: FlatFigure[];
+    properties: VectorTileFeatureProperties;
+}[];

package/dist/3d-building-layer/3d-building-utils.js

@@ -0,0 +1,212 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTileData = getTileData;
+exports.decodeTile = decodeTile;
+exports.vectorTileFeatureToProp = vectorTileFeatureToProp;
+
+var _pbf = _interopRequireDefault(require("pbf"));
+
+var _vectorTile = require("@mapbox/vector-tile");
+
+var _viewportMercatorProject = require("viewport-mercator-project");/* global fetch */
+var TILE_SIZE = 512;
+var MAPBOX_HOST = 'https://a.tiles.mapbox.com';
+var MAP_SOURCE = '/v4/mapbox.mapbox-streets-v7';
+
+function getTileData(host, token, _ref) {
+  var x = _ref.x,
+      y = _ref.y,
+      z = _ref.z;
+  var mapSource = "".concat(host || MAPBOX_HOST).concat(MAP_SOURCE, "/").concat(z, "/").concat(x, "/").concat(y, ".vector.pbf?access_token=").concat(token);
+  return fetch(mapSource).then(function (response) {
+    return response.arrayBuffer();
+  }).then(function (buffer) {
+    return decodeTile(x, y, z, buffer);
+  });
+}
+
+function decodeTile(x, y, z, arrayBuffer) {
+  var tile = new _vectorTile.VectorTile(new _pbf["default"](arrayBuffer));
+  var result = [];
+  var xProj = x * TILE_SIZE;
+  var yProj = y * TILE_SIZE;
+  var scale = Math.pow(2, z);
+  var projectFunc = project.bind(null, xProj, yProj, scale);
+  /* eslint-disable guard-for-in */
+
+  var layerName = 'building';
+  var vectorTileLayer = tile.layers[layerName];
+
+  if (!vectorTileLayer) {
+    return [];
+  }
+
+  for (var i = 0; i < vectorTileLayer.length; i++) {
+    var vectorTileFeature = vectorTileLayer.feature(i);
+    var features = vectorTileFeatureToProp(vectorTileFeature, projectFunc);
+    features.forEach(function (f) {
+      f.properties.layer = layerName;
+
+      if (f.properties.height) {
+        result.push(f);
+      }
+    });
+  }
+
+  return result;
+}
+
+function project(x, y, scale, line, extent) {
+  var sizeToPixel = extent / TILE_SIZE;
+
+  for (var ii = 0; ii < line.length; ii++) {
+    var p = line[ii]; // LNGLAT
+
+    line[ii] = (0, _viewportMercatorProject.worldToLngLat)([x + p[0] / sizeToPixel, y + p[1] / sizeToPixel], scale);
+  }
+}
+/* adapted from @mapbox/vector-tile/lib/vectortilefeature.js for better perf */
+
+/* eslint-disable */
+
+
+function vectorTileFeatureToProp(vectorTileFeature, project) {
+  var coords = getCoordinates(vectorTileFeature);
+  var extent = vectorTileFeature.extent;
+  var i;
+  var j;
+  coords = classifyRings(coords);
+
+  for (i = 0; i < coords.length; i++) {
+    for (j = 0; j < coords[i].length; j++) {
+      project(coords[i][j], extent);
+    }
+  }
+
+  return coords.map(function (coordinates) {
+    return {
+      coordinates: coordinates,
+      properties: vectorTileFeature.properties
+    };
+  });
+}
+
+function getCoordinates(vectorTileFeature) {
+  var pbf = vectorTileFeature._pbf;
+  pbf.pos = vectorTileFeature._geometry;
+  var end = pbf.readVarint() + pbf.pos;
+  var cmd = 1;
+  var length = 0;
+  var x = 0;
+  var y = 0;
+  var lines = [];
+  var line;
+
+  while (pbf.pos < end) {
+    if (length <= 0) {
+      var cmdLen = pbf.readVarint();
+      cmd = cmdLen & 0x7;
+      length = cmdLen >> 3;
+    }
+
+    length--;
+
+    if (cmd === 1 || cmd === 2) {
+      x += pbf.readSVarint();
+      y += pbf.readSVarint();
+
+      if (cmd === 1) {
+        // moveTo
+        if (line) lines.push(line);
+        line = [];
+      }
+
+      if (line) line.push([x, y]);
+    } else if (cmd === 7) {
+      // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
+      if (line) {
+        line.push(line[0].slice()); // closePolygon
+      }
+    } else {
+      throw new Error("unknown command ".concat(cmd));
+    }
+  }
+
+  if (line) lines.push(line);
+  return lines;
+} // classifies an array of rings into polygons with outer rings and holes
+
+
+function classifyRings(rings) {
+  var len = rings.length;
+  if (len <= 1) return [rings];
+  var polygons = [];
+  var polygon;
+  var ccw;
+
+  for (var i = 0; i < len; i++) {
+    var area = signedArea(rings[i]);
+
+    if (area === 0) {
+      continue;
+    }
+
+    if (ccw === undefined) {
+      ccw = area < 0;
+    }
+
+    if (ccw === area < 0) {
+      if (polygon) {
+        polygons.push(polygon);
+      }
+
+      polygon = [rings[i]];
+    } else if (polygon) {
+      polygon.push(rings[i]);
+    }
+  }
+
+  if (polygon) {
+    polygons.push(polygon);
+  }
+
+  return polygons;
+}
+
+function signedArea(ring) {
+  var sum = 0;
+
+  for (var i = 0, len = ring.length, j = len - 1, p1, p2; i < len; j = i++) {
+    p1 = ring[i];
+    p2 = ring[j];
+    sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
+  }
+
+  return sum;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/3d-building-layer/3d-building-utils.ts"],"names":["TILE_SIZE","MAPBOX_HOST","MAP_SOURCE","getTileData","host","token","x","y","z","mapSource","fetch","then","response","arrayBuffer","buffer","decodeTile","tile","VectorTile","Protobuf","result","xProj","yProj","scale","Math","pow","projectFunc","project","bind","layerName","vectorTileLayer","layers","i","length","vectorTileFeature","feature","features","vectorTileFeatureToProp","forEach","f","properties","layer","height","push","line","extent","sizeToPixel","ii","p","coords","getCoordinates","j","classifyRings","map","coordinates","pbf","_pbf","pos","_geometry","end","readVarint","cmd","lines","cmdLen","readSVarint","slice","Error","rings","len","polygons","polygon","ccw","area","signedArea","undefined","ring","sum","p1","p2"],"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 Protobuf from 'pbf';\nimport {VectorTile} from '@mapbox/vector-tile';\nimport {worldToLngLat} from 'viewport-mercator-project';\nimport {\n  Coordinates,\n  FlatFigure,\n  TileDataItem,\n  VectorTileFeature,\n  VectorTileFeatureProperties\n} from './types';\n\n/* global fetch */\nconst TILE_SIZE = 512;\nconst MAPBOX_HOST = 'https://a.tiles.mapbox.com';\nconst MAP_SOURCE = '/v4/mapbox.mapbox-streets-v7';\n\nexport function getTileData(\n  host: string,\n  token: string,\n  {x, y, z}: Coordinates\n): Promise<TileDataItem[]> {\n  const mapSource = `${host ||\n    MAPBOX_HOST}${MAP_SOURCE}/${z}/${x}/${y}.vector.pbf?access_token=${token}`;\n\n  return fetch(mapSource)\n    .then(response => response.arrayBuffer())\n    .then(buffer => decodeTile(x, y, z, buffer));\n}\n\nexport function decodeTile(\n  x: number,\n  y: number,\n  z: number,\n  arrayBuffer: ArrayBuffer\n): TileDataItem[] {\n  const tile = new VectorTile(new Protobuf(arrayBuffer));\n\n  const result: TileDataItem[] = [];\n  const xProj = x * TILE_SIZE;\n  const yProj = y * TILE_SIZE;\n  const scale = Math.pow(2, z);\n\n  const projectFunc = project.bind(null, xProj, yProj, scale);\n\n  /* eslint-disable guard-for-in */\n  const layerName = 'building';\n  const vectorTileLayer = tile.layers[layerName];\n  if (!vectorTileLayer) {\n    return [];\n  }\n  for (let i = 0; i < vectorTileLayer.length; i++) {\n    const vectorTileFeature = vectorTileLayer.feature(i);\n    const features = vectorTileFeatureToProp(vectorTileFeature, projectFunc);\n    features.forEach(f => {\n      f.properties.layer = layerName;\n      if (f.properties.height) {\n        result.push(f);\n      }\n    });\n  }\n  return result;\n}\n\nfunction project(x: number, y: number, scale: number, line: FlatFigure, extent: number): void {\n  const sizeToPixel = extent / TILE_SIZE;\n\n  for (let ii = 0; ii < line.length; ii++) {\n    const p = line[ii];\n    // LNGLAT\n    line[ii] = worldToLngLat([x + p[0] / sizeToPixel, y + p[1] / sizeToPixel], scale);\n  }\n}\n\n/* adapted from @mapbox/vector-tile/lib/vectortilefeature.js for better perf */\n/* eslint-disable */\nexport function vectorTileFeatureToProp(\n  vectorTileFeature: VectorTileFeature,\n  project: (r: FlatFigure, n: number) => void\n): {coordinates: FlatFigure[]; properties: VectorTileFeatureProperties}[] {\n  let coords: FlatFigure[][] | FlatFigure[] = getCoordinates(vectorTileFeature);\n  const extent = vectorTileFeature.extent;\n  let i: number;\n  let j: number;\n\n  coords = classifyRings(coords);\n  for (i = 0; i < coords.length; i++) {\n    for (j = 0; j < coords[i].length; j++) {\n      project(coords[i][j], extent);\n    }\n  }\n\n  return coords.map(coordinates => ({\n    coordinates,\n    properties: vectorTileFeature.properties\n  }));\n}\n\nfunction getCoordinates(vectorTileFeature: VectorTileFeature): FlatFigure[] {\n  const pbf = vectorTileFeature._pbf;\n  pbf.pos = vectorTileFeature._geometry;\n\n  const end = pbf.readVarint() + pbf.pos;\n  let cmd = 1;\n  let length = 0;\n  let x = 0;\n  let y = 0;\n\n  const lines: FlatFigure[] = [];\n  let line: FlatFigure | undefined;\n\n  while (pbf.pos < end) {\n    if (length <= 0) {\n      const cmdLen = pbf.readVarint();\n      cmd = cmdLen & 0x7;\n      length = cmdLen >> 3;\n    }\n\n    length--;\n\n    if (cmd === 1 || cmd === 2) {\n      x += pbf.readSVarint();\n      y += pbf.readSVarint();\n\n      if (cmd === 1) {\n        // moveTo\n        if (line) lines.push(line);\n        line = [];\n      }\n\n      if (line) line.push([x, y]);\n    } else if (cmd === 7) {\n      // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90\n      if (line) {\n        line.push(line[0].slice() as [number, number] | [number, number, number]); // closePolygon\n      }\n    } else {\n      throw new Error(`unknown command ${cmd}`);\n    }\n  }\n\n  if (line) lines.push(line);\n\n  return lines;\n}\n\n// classifies an array of rings into polygons with outer rings and holes\n\nfunction classifyRings(rings: FlatFigure[]): FlatFigure[][] {\n  const len = rings.length;\n\n  if (len <= 1) return [rings];\n\n  const polygons: FlatFigure[][] = [];\n  let polygon: FlatFigure[] | undefined;\n  let ccw: boolean | undefined;\n\n  for (let i = 0; i < len; i++) {\n    const area = signedArea(rings[i]);\n    if (area === 0) {\n      continue;\n    }\n\n    if (ccw === undefined) {\n      ccw = area < 0;\n    }\n\n    if (ccw === area < 0) {\n      if (polygon) {\n        polygons.push(polygon);\n      }\n      polygon = [rings[i]];\n    } else if (polygon) {\n      polygon.push(rings[i]);\n    }\n  }\n  if (polygon) {\n    polygons.push(polygon);\n  }\n\n  return polygons;\n}\n\nfunction signedArea(ring: FlatFigure): number {\n  let sum = 0;\n  for (let i = 0, len = ring.length, j = len - 1, p1: number[], p2: number[]; i < len; j = i++) {\n    p1 = ring[i];\n    p2 = ring[j];\n    sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);\n  }\n  return sum;\n}\n"]}

package/dist/3d-building-layer/types.d.ts

@@ -0,0 +1,37 @@
+import { RGBColor } from '@kepler.gl/types';
+export declare type ThreeDBuildingLayerProps = {
+    id: string;
+    mapboxApiAccessToken: string;
+    mapboxApiUrl: string;
+    threeDBuildingColor: RGBColor;
+    updateTriggers: {
+        getFillColor: RGBColor;
+    };
+};
+export declare type Coordinates = {
+    x: number;
+    y: number;
+    z: number;
+};
+export declare type FlatFigure = ([number, number] | [number, number, number])[];
+export declare type TileDataItem = {
+    coordinates: FlatFigure[];
+    properties: VectorTileFeatureProperties;
+};
+export declare type VectorTileFeatureProperties = {
+    layer: string;
+    height?: number;
+};
+export declare type VectorTileFeature = {
+    extent: number;
+    properties: VectorTileFeatureProperties;
+    _pbf: {
+        buf: ArrayBuffer;
+        pos: number;
+        type: number;
+        length: number;
+        readVarint: (b?: boolean) => number;
+        readSVarint: () => number;
+    };
+    _geometry: number;
+};

package/dist/3d-building-layer/types.js

@@ -0,0 +1,26 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=

package/dist/cluster-layer/cluster-layer.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="deck.gl" />
+/// <reference types="@deck.gl/core" />
+/// <reference types="@danmarshall/deckgl-typings/deck.gl__core" />
+import { ScatterplotLayer } from '@deck.gl/layers';
+import { _AggregationLayer as AggregationLayer } from '@deck.gl/aggregation-layers';
+import { AggregationType } from '../layer-utils/cpu-aggregator';
+import { AggregationLayerProps } from '@deck.gl/aggregation-layers/aggregation-layer';
+export declare const clusterAggregation: AggregationType;
+export default class ClusterLayer extends AggregationLayer<any, AggregationLayerProps<any> & {
+    radiusScale: number;
+}> {
+    initializeState(): void;
+    updateState({ oldProps, props, changeFlags }: {
+        oldProps: any;
+        props: any;
+        changeFlags: any;
+    }): void;
+    getPickingInfo({ info }: {
+        info: any;
+    }): any;
+    _getSublayerUpdateTriggers(): any;
+    _getSubLayerAccessors(): {
+        getRadius: any;
+        getFillColor: any;
+    };
+    renderLayers(): ScatterplotLayer<unknown, {
+        getRadius: any;
+        getFillColor: any;
+        id: string;
+        data: any;
+        radiusScale: number;
+        visible: boolean | undefined;
+        opacity: number | undefined;
+        pickable: boolean | undefined;
+        autoHighlight: boolean | undefined;
+        highlightColor: import("@deck.gl/core/utils/color").RGBAColor | ((pickInfo: import("@deck.gl/core/lib/deck").PickInfo<any>) => import("@deck.gl/core/utils/color").RGBAColor) | undefined;
+        updateTriggers: any;
+        parameters: {
+            depthMask: boolean;
+        };
+    }>;
+}