@kepler.gl/deckgl-layers 3.1.0-alpha.1 → 3.1.0-alpha.3

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

@@ -0,0 +1,16 @@
+import { CompositeLayer } from '@deck.gl/core/typed';
+import { TileLayer as DeckGLTileLayer } from '@deck.gl/geo-layers/typed';
+import { SolidPolygonLayer, SolidPolygonLayerProps } from '@deck.gl/layers/typed';
+import { ThreeDBuildingLayerProps, TileDataItem, TileLoadProps } from './types';
+export default class ThreeDBuildingLayer extends CompositeLayer<ThreeDBuildingLayerProps> {
+    renderSubLayers(props: SolidPolygonLayerProps<any>): SolidPolygonLayer<TileDataItem, {}>;
+    renderLayers(): DeckGLTileLayer<any, {
+        id: string;
+        getTileData: (tile: TileLoadProps) => Promise<TileDataItem[]>;
+        minZoom: 13;
+        renderSubLayers: (props: SolidPolygonLayerProps<any>) => SolidPolygonLayer<TileDataItem, {}>;
+        updateTriggers: {
+            getFillColor: import("@kepler.gl/types").RGBColor;
+        } & Record<string, any>;
+    }>[];
+}

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

@@ -0,0 +1,69 @@
+"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 _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
+var _typed = require("@deck.gl/core/typed");
+var _typed2 = require("@deck.gl/geo-layers/typed");
+var _typed3 = require("@deck.gl/layers/typed");
+var _dBuildingUtils = require("./3d-building-utils");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+var ThreeDBuildingLayer = exports["default"] = /*#__PURE__*/function (_CompositeLayer) {
+  function ThreeDBuildingLayer() {
+    (0, _classCallCheck2["default"])(this, ThreeDBuildingLayer);
+    return _callSuper(this, ThreeDBuildingLayer, arguments);
+  }
+  (0, _inherits2["default"])(ThreeDBuildingLayer, _CompositeLayer);
+  return (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 _typed3.SolidPolygonLayer(_objectSpread(_objectSpread({}, props), {}, {
+        parameters: {
+          blendFunc: [_constants["default"].SRC_ALPHA, _constants["default"].ONE_MINUS_SRC_ALPHA, _constants["default"].ONE, _constants["default"].ONE_MINUS_SRC_ALPHA],
+          blendEquation: [_constants["default"].FUNC_ADD, _constants["default"].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 _typed2.TileLayer({
+        id: "".concat(this.id, "-deck-3d-building"),
+        getTileData: function getTileData(tile) {
+          return (0, _dBuildingUtils.getTileData)(_this.props.mapboxApiUrl, _this.props.mapboxApiAccessToken, tile);
+        },
+        minZoom: 13,
+        renderSubLayers: this.renderSubLayers.bind(this),
+        updateTriggers: this.props.updateTriggers
+      })];
+    }
+  }]);
+}(_typed.CompositeLayer);
+//# 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,9 @@
+import { Coordinates, FlatFigure, TileDataItem, VectorTileFeature, VectorTileFeatureProperties } from './types';
+export declare function getTileData(host: string, token: string, { index: { x, y, z } }: {
+    index: 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,166 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decodeTile = decodeTile;
+exports.getTileData = getTileData;
+exports.vectorTileFeatureToProp = vectorTileFeatureToProp;
+var _pbf = _interopRequireDefault(require("pbf"));
+var _vectorTile = require("@mapbox/vector-tile");
+var _viewportMercatorProject = require("viewport-mercator-project");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl 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 _ref$index = _ref.index,
+    x = _ref$index.x,
+    y = _ref$index.y,
+    z = _ref$index.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);
+    // @ts-ignore
+    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,"names":["_pbf","_interopRequireDefault","require","_vectorTile","_viewportMercatorProject","TILE_SIZE","MAPBOX_HOST","MAP_SOURCE","getTileData","host","token","_ref","_ref$index","index","x","y","z","mapSource","concat","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","worldToLngLat","coords","getCoordinates","j","classifyRings","map","coordinates","pbf","pos","_geometry","end","readVarint","cmd","lines","cmdLen","readSVarint","slice","Error","rings","len","polygons","polygon","ccw","area","signedArea","undefined","ring","sum","p1","p2"],"sources":["../../src/3d-building-layer/3d-building-utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\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  {index: {x, y, z}}: {index: Coordinates}\n): Promise<TileDataItem[]> {\n  const mapSource = `${\n    host || MAPBOX_HOST\n  }${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    // @ts-ignore\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"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,51 @@
+import { RGBColor } from '@kepler.gl/types';
+export declare type TileIndex = {
+    x: number;
+    y: number;
+    z: number;
+};
+export declare type TileLoadProps = {
+    id: string;
+    index: TileIndex;
+    bbox: any;
+    url?: string | null;
+    signal?: AbortSignal;
+    userData?: Record<string, any>;
+    zoom?: number;
+};
+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,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjLzNkLWJ1aWxkaW5nLWxheWVyL3R5cGVzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVRcbi8vIENvcHlyaWdodCBjb250cmlidXRvcnMgdG8gdGhlIGtlcGxlci5nbCBwcm9qZWN0XG5cbmltcG9ydCB7UkdCQ29sb3J9IGZyb20gJ0BrZXBsZXIuZ2wvdHlwZXMnO1xuXG5leHBvcnQgdHlwZSBUaWxlSW5kZXggPSB7eDogbnVtYmVyOyB5OiBudW1iZXI7IHo6IG51bWJlcn07XG5cbmV4cG9ydCB0eXBlIFRpbGVMb2FkUHJvcHMgPSB7XG4gIGlkOiBzdHJpbmc7XG4gIGluZGV4OiBUaWxlSW5kZXg7XG4gIGJib3g6IGFueTtcbiAgdXJsPzogc3RyaW5nIHwgbnVsbDtcbiAgc2lnbmFsPzogQWJvcnRTaWduYWw7XG4gIHVzZXJEYXRhPzogUmVjb3JkPHN0cmluZywgYW55PjtcbiAgem9vbT86IG51bWJlcjtcbn07XG5cbmV4cG9ydCB0eXBlIFRocmVlREJ1aWxkaW5nTGF5ZXJQcm9wcyA9IHtcbiAgaWQ6IHN0cmluZztcbiAgbWFwYm94QXBpQWNjZXNzVG9rZW46IHN0cmluZztcbiAgbWFwYm94QXBpVXJsOiBzdHJpbmc7XG4gIHRocmVlREJ1aWxkaW5nQ29sb3I6IFJHQkNvbG9yO1xuICB1cGRhdGVUcmlnZ2Vyczoge1xuICAgIGdldEZpbGxDb2xvcjogUkdCQ29sb3I7XG4gIH07XG59O1xuZXhwb3J0IHR5cGUgQ29vcmRpbmF0ZXMgPSB7eDogbnVtYmVyOyB5OiBudW1iZXI7IHo6IG51bWJlcn07XG4vLyBUT0RPIHJlbmFtZVxuZXhwb3J0IHR5cGUgRmxhdEZpZ3VyZSA9IChbbnVtYmVyLCBudW1iZXJdIHwgW251bWJlciwgbnVtYmVyLCBudW1iZXJdKVtdO1xuZXhwb3J0IHR5cGUgVGlsZURhdGFJdGVtID0ge2Nvb3JkaW5hdGVzOiBGbGF0RmlndXJlW107IHByb3BlcnRpZXM6IFZlY3RvclRpbGVGZWF0dXJlUHJvcGVydGllc307XG5leHBvcnQgdHlwZSBWZWN0b3JUaWxlRmVhdHVyZVByb3BlcnRpZXMgPSB7bGF5ZXI6IHN0cmluZzsgaGVpZ2h0PzogbnVtYmVyfTtcbmV4cG9ydCB0eXBlIFZlY3RvclRpbGVGZWF0dXJlID0ge1xuICBleHRlbnQ6IG51bWJlcjtcbiAgcHJvcGVydGllczogVmVjdG9yVGlsZUZlYXR1cmVQcm9wZXJ0aWVzO1xuICBfcGJmOiB7XG4gICAgYnVmOiBBcnJheUJ1ZmZlcjtcbiAgICBwb3M6IG51bWJlcjtcbiAgICB0eXBlOiBudW1iZXI7XG4gICAgbGVuZ3RoOiBudW1iZXI7XG4gICAgcmVhZFZhcmludDogKGI/OiBib29sZWFuKSA9PiBudW1iZXI7XG4gICAgcmVhZFNWYXJpbnQ6ICgpID0+IG51bWJlcjtcbiAgfTtcbiAgX2dlb21ldHJ5OiBudW1iZXI7XG59O1xuIl0sIm1hcHBpbmdzIjoiIiwiaWdub3JlTGlzdCI6W119

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

@@ -0,0 +1,44 @@
+/// <reference types="deck.gl" />
+/// <reference types="deck.gl" />
+/// <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;
+        };
+    }>;
+}