@deck.gl/geo-layers 8.8.0-alpha.6 → 8.8.0-beta.3

package/src/tile-3d-layer/{tile-3d-layer.js → tile-3d-layer.ts}

@@ -1,21 +1,38 @@
 import GL from '@luma.gl/constants';
 import {Geometry} from '@luma.gl/core';
-import {COORDINATE_SYSTEM, CompositeLayer} from '@deck.gl/core';
+
+import {
+  Accessor,
+  Color,
+  CompositeLayer,
+  CompositeLayerProps,
+  COORDINATE_SYSTEM,
+  FilterContext,
+  GetPickingInfoParams,
+  Layer,
+  LayersList,
+  log,
+  PickingInfo,
+  UpdateParameters,
+  Viewport,
+  DefaultProps
+} from '@deck.gl/core';
 import {PointCloudLayer} from '@deck.gl/layers';
 import {ScenegraphLayer} from '@deck.gl/mesh-layers';
-import {default as _MeshLayer} from '../mesh-layer/mesh-layer';
-import {log} from '@deck.gl/core';
+import {default as MeshLayer} from '../mesh-layer/mesh-layer';
 
 import {load} from '@loaders.gl/core';
-import {Tileset3D, TILE_TYPE} from '@loaders.gl/tiles';
+import {MeshAttributes} from '@loaders.gl/schema';
+import {Tileset3D, Tile3D, TILE_TYPE} from '@loaders.gl/tiles';
 import {Tiles3DLoader} from '@loaders.gl/3d-tiles';
 
 const SINGLE_DATA = [0];
 
-const defaultProps = {
+const defaultProps: DefaultProps<Tile3DLayerProps> = {
   getPointColor: {type: 'accessor', value: [0, 0, 0, 255]},
   pointSize: 1.0,
 
+  // @ts-expect-error Disable async data loading (handling it in _loadTileSet)
   data: null,
   loader: Tiles3DLoader,
 
@@ -26,7 +43,52 @@ const defaultProps = {
   _getMeshColor: {type: 'function', value: tileHeader => [255, 255, 255], compare: false}
 };
 
-export default class Tile3DLayer extends CompositeLayer {
+/** All properties supported by Tile3DLayer */
+export type Tile3DLayerProps<DataT = any> = _Tile3DLayerProps<DataT> & CompositeLayerProps<DataT>;
+
+/** Props added by the Tile3DLayer */
+type _Tile3DLayerProps<DataT> = {
+  /** Color Accessor for point clouds. **/
+  getPointColor?: Accessor<DataT, Color>;
+
+  /** Global radius of all points in pixels. **/
+  pointSize?: number;
+
+  /** A loader which is used to decode the fetched tiles.
+   * @deprecated Use `loaders` instead
+   */
+  loader?: typeof Tiles3DLoader;
+
+  /** Called when Tileset JSON file is loaded. **/
+  onTilesetLoad?: (tile: Tileset3D) => void;
+
+  /** Called when a tile in the tileset hierarchy is loaded. **/
+  onTileLoad?: (tile: Tile3D) => void;
+
+  /** Called when a tile is unloaded. **/
+  onTileUnload?: (tile: Tile3D) => void;
+
+  /** Called when a tile fails to load. **/
+  onTileError?: (tile: Tile3D, url: string, message: string) => void;
+
+  /** (Experimental) Accessor to change color of mesh based on properties. **/
+  _getMeshColor?: (tile: Tile3D) => Color;
+};
+
+export default class Tile3DLayer<DataT = any, ExtraPropsT = {}> extends CompositeLayer<
+  ExtraPropsT & Required<_Tile3DLayerProps<DataT>>
+> {
+  static defaultProps = defaultProps as any;
+  static layerName = 'Tile3DLayer';
+
+  state!: {
+    activeViewports: {};
+    frameNumber?: number;
+    lastUpdatedViewports: {[viewportId: string]: Viewport} | null;
+    layerMap: {[layerId: string]: any};
+    tileset3d: Tileset3D | null;
+  };
+
   initializeState() {
     if ('onTileLoadFail' in this.props) {
       log.removed('onTileLoadFail', 'onTileError')();
@@ -40,16 +102,16 @@ export default class Tile3DLayer extends CompositeLayer {
     };
   }
 
-  get isLoaded() {
+  get isLoaded(): boolean {
     const {tileset3d} = this.state;
-    return tileset3d && tileset3d.isLoaded();
+    return tileset3d !== null && tileset3d.isLoaded();
   }
 
-  shouldUpdateState({changeFlags}) {
+  shouldUpdateState({changeFlags}: UpdateParameters<this>): boolean {
     return changeFlags.somethingChanged;
   }
 
-  updateState({props, oldProps, changeFlags}) {
+  updateState({props, oldProps, changeFlags}: UpdateParameters<this>): void {
     if (props.data && props.data !== oldProps.data) {
       this._loadTileset(props.data);
     }
@@ -71,9 +133,9 @@ export default class Tile3DLayer extends CompositeLayer {
     }
   }
 
-  activateViewport(viewport) {
+  activateViewport(viewport: Viewport): void {
     const {activeViewports, lastUpdatedViewports} = this.state;
-    this.internalState.viewport = viewport;
+    this.internalState!.viewport = viewport;
 
     activeViewports[viewport.id] = viewport;
     const lastViewport = lastUpdatedViewports?.[viewport.id];
@@ -83,7 +145,7 @@ export default class Tile3DLayer extends CompositeLayer {
     }
   }
 
-  getPickingInfo({info, sourceLayer}) {
+  getPickingInfo({info, sourceLayer}: GetPickingInfoParams) {
     const {layerMap} = this.state;
     const layerId = sourceLayer && sourceLayer.id;
     if (layerId) {
@@ -96,22 +158,24 @@ export default class Tile3DLayer extends CompositeLayer {
     return info;
   }
 
-  filterSubLayer({layer, viewport}) {
-    const {tile} = layer.props;
+  filterSubLayer({layer, viewport}: FilterContext): boolean {
+    // All sublayers will have a tile prop
+    const {tile} = layer.props as unknown as {tile: Tile3D};
     const {id: viewportId} = viewport;
     return tile.selected && tile.viewportIds.includes(viewportId);
   }
 
-  _updateAutoHighlight(info) {
+  protected _updateAutoHighlight(info: PickingInfo): void {
     if (info.sourceLayer) {
       info.sourceLayer.updateAutoHighlight(info);
     }
   }
 
-  async _loadTileset(tilesetUrl) {
+  private async _loadTileset(tilesetUrl) {
     const {loadOptions = {}} = this.props;
 
     // TODO: deprecate `loader` in v9.0
+    // @ts-ignore
     let loader = this.props.loader || this.props.loaders;
     if (Array.isArray(loader)) {
       loader = loader[0];
@@ -134,7 +198,7 @@ export default class Tile3DLayer extends CompositeLayer {
     const tileset3d = new Tileset3D(tilesetJson, {
       onTileLoad: this._onTileLoad.bind(this),
       onTileUnload: this._onTileUnload.bind(this),
-      onTileLoadFail: this.props.onTileError,
+      onTileError: this.props.onTileError,
       ...options
     });
 
@@ -147,20 +211,23 @@ export default class Tile3DLayer extends CompositeLayer {
     this.props.onTilesetLoad(tileset3d);
   }
 
-  _onTileLoad(tileHeader) {
+  private _onTileLoad(tileHeader: Tile3D): void {
     const {lastUpdatedViewports} = this.state;
     this.props.onTileLoad(tileHeader);
     this._updateTileset(lastUpdatedViewports);
     this.setNeedsUpdate();
   }
 
-  _onTileUnload(tileHeader) {
+  private _onTileUnload(tileHeader: Tile3D): void {
     // Was cleaned up from tileset cache. We no longer need to track it.
     delete this.state.layerMap[tileHeader.id];
     this.props.onTileUnload(tileHeader);
   }
 
-  _updateTileset(viewports) {
+  private _updateTileset(viewports: {[viewportId: string]: Viewport} | null): void {
+    if (!viewports) {
+      return;
+    }
     const {tileset3d} = this.state;
     const {timeline} = this.context;
     const viewportsNumber = Object.keys(viewports).length;
@@ -175,24 +242,30 @@ export default class Tile3DLayer extends CompositeLayer {
     });
   }
 
-  _getSubLayer(tileHeader, oldLayer) {
+  private _getSubLayer(
+    tileHeader: Tile3D,
+    oldLayer?: Layer
+  ): MeshLayer<DataT> | PointCloudLayer<DataT> | ScenegraphLayer<DataT> | null {
     if (!tileHeader.content) {
       return null;
     }
 
     switch (tileHeader.type) {
       case TILE_TYPE.POINTCLOUD:
-        return this._makePointCloudLayer(tileHeader, oldLayer);
+        return this._makePointCloudLayer(tileHeader, oldLayer as PointCloudLayer<DataT>);
       case TILE_TYPE.SCENEGRAPH:
-        return this._make3DModelLayer(tileHeader, oldLayer);
+        return this._make3DModelLayer(tileHeader);
       case TILE_TYPE.MESH:
-        return this._makeSimpleMeshLayer(tileHeader, oldLayer);
+        return this._makeSimpleMeshLayer(tileHeader, oldLayer as MeshLayer<DataT>);
       default:
         throw new Error(`Tile3DLayer: Failed to render layer of type ${tileHeader.content.type}`);
     }
   }
 
-  _makePointCloudLayer(tileHeader, oldLayer) {
+  private _makePointCloudLayer(
+    tileHeader: Tile3D,
+    oldLayer?: PointCloudLayer<DataT>
+  ): PointCloudLayer<DataT> | null {
     const {attributes, pointCount, constantRGBA, cartographicOrigin, modelMatrix} =
       tileHeader.content;
     const {positions, normals, colors} = attributes;
@@ -233,7 +306,7 @@ export default class Tile3DLayer extends CompositeLayer {
     );
   }
 
-  _make3DModelLayer(tileHeader) {
+  private _make3DModelLayer(tileHeader: Tile3D): ScenegraphLayer<DataT> {
     const {gltf, instances, cartographicOrigin, modelMatrix} = tileHeader.content;
 
     const SubLayerClass = this.getSubLayerClass('scenegraph', ScenegraphLayer);
@@ -261,7 +334,7 @@ export default class Tile3DLayer extends CompositeLayer {
     );
   }
 
-  _makeSimpleMeshLayer(tileHeader, oldLayer) {
+  private _makeSimpleMeshLayer(tileHeader: Tile3D, oldLayer?: MeshLayer<DataT>): MeshLayer<DataT> {
     const content = tileHeader.content;
     const {
       attributes,
@@ -282,7 +355,7 @@ export default class Tile3DLayer extends CompositeLayer {
         indices
       });
 
-    const SubLayerClass = this.getSubLayerClass('mesh', _MeshLayer);
+    const SubLayerClass = this.getSubLayerClass('mesh', MeshLayer);
 
     return new SubLayerClass(
       this.getSubLayerProps({
@@ -304,13 +377,14 @@ export default class Tile3DLayer extends CompositeLayer {
     );
   }
 
-  renderLayers() {
+  renderLayers(): Layer | null | LayersList {
     const {tileset3d, layerMap} = this.state;
     if (!tileset3d) {
       return null;
     }
 
-    return tileset3d.tiles
+    // loaders.gl doesn't provide a type for tileset3d.tiles
+    return (tileset3d.tiles as Tile3D[])
       .map(tile => {
         const layerCache = (layerMap[tile.id] = layerMap[tile.id] || {tile});
         let {layer} = layerCache;
@@ -332,8 +406,8 @@ export default class Tile3DLayer extends CompositeLayer {
   }
 }
 
-function getMeshGeometry(contentAttributes) {
-  const attributes = {};
+function getMeshGeometry(contentAttributes: MeshAttributes): MeshAttributes {
+  const attributes: MeshAttributes = {};
   attributes.positions = {
     ...contentAttributes.positions,
     value: new Float32Array(contentAttributes.positions.value)
@@ -352,6 +426,3 @@ function getMeshGeometry(contentAttributes) {
   }
   return attributes;
 }
-
-Tile3DLayer.layerName = 'Tile3DLayer';
-Tile3DLayer.defaultProps = defaultProps;

package/src/tile-layer/tile-layer.ts

@@ -6,6 +6,8 @@ import {
   UpdateParameters,
   PickingInfo,
   GetPickingInfoParams,
+  DefaultProps,
+  FilterContext,
   _flatten as flatten
 } from '@deck.gl/core';
 import {GeoJsonLayer} from '@deck.gl/layers';
@@ -16,9 +18,9 @@ import Tileset2D, {RefinementStrategy, STRATEGY_DEFAULT, Tileset2DProps} from '.
 import {TileLoadProps, ZRange} from './types';
 import {urlType, getURLFromTemplate} from './utils';
 
-const defaultProps = {
+const defaultProps: DefaultProps<TileLayerProps> = {
   TilesetClass: Tileset2D,
-  data: [],
+  data: {type: 'data', value: []},
   dataComparator: urlType.equals,
   renderSubLayers: {type: 'function', value: props => new GeoJsonLayer(props), compare: false},
   getTileData: {type: 'function', optional: true, value: null, compare: false},
@@ -41,7 +43,7 @@ const defaultProps = {
 };
 
 /** All props supported by the TileLayer */
-export type TileLayerProps<DataT = any> = _TileLayerProps<DataT> & CompositeLayerProps<DataT>;
+export type TileLayerProps<DataT = any> = CompositeLayerProps<any> & _TileLayerProps<DataT>;
 
 /** Props added by the TileLayer */
 type _TileLayerProps<DataT> = {
@@ -63,10 +65,10 @@ type _TileLayerProps<DataT> = {
   /**
    * If supplied, `getTileData` is called to retrieve the data of each tile.
    */
-  getTileData?: (props: TileLoadProps) => Promise<DataT> | DataT;
+  getTileData?: ((props: TileLoadProps) => Promise<DataT> | DataT) | null;
 
   /** Called when all tiles in the current viewport are loaded. */
-  onViewportLoad?: (tiles: Tile2DHeader<DataT>[]) => void;
+  onViewportLoad?: ((tiles: Tile2DHeader<DataT>[]) => void) | null;
 
   /** Called when a tile successfully loads. */
   onTileLoad?: (tile: Tile2DHeader<DataT>) => void;
@@ -332,7 +334,7 @@ export default class TileLayer<DataT = any, ExtraPropsT = {}> extends CompositeL
           _offset: 0,
           tile
         });
-        tile.layers = (flatten(layers, Boolean) as Layer[]).map(layer =>
+        tile.layers = (flatten(layers, Boolean) as Layer<{tile?: Tile2DHeader}>[]).map(layer =>
           layer.clone({
             tile,
             ...subLayerProps
@@ -351,7 +353,8 @@ export default class TileLayer<DataT = any, ExtraPropsT = {}> extends CompositeL
     });
   }
 
-  filterSubLayer({layer}) {
-    return layer.props.tile.isVisible;
+  filterSubLayer({layer, cullRect}: FilterContext) {
+    const {tile} = (layer as Layer<{tile: Tile2DHeader}>).props;
+    return this.state.tileset.isTileVisible(tile, cullRect);
   }
 }

package/src/tile-layer/tileset-2d.ts

@@ -1,10 +1,11 @@
 import Tile2DHeader from './tile-2d-header';
-import {getTileIndices, tileToBoundingBox} from './utils';
+import {getTileIndices, tileToBoundingBox, getCullBounds} from './utils';
 import {RequestScheduler} from '@loaders.gl/loader-utils';
-import {Matrix4} from '@math.gl/core';
+import {Matrix4, equals} from '@math.gl/core';
 import {Viewport} from '@deck.gl/core';
 import {Bounds, TileIndex, ZRange} from './types';
 import {TileLayerProps} from './tile-layer';
+import {_memoize as memoize} from '@deck.gl/core';
 
 // bit masks
 const TILE_STATE_VISITED = 1;
@@ -49,7 +50,6 @@ const STRATEGIES = {
 
 export type Tileset2DProps = Pick<
   Required<TileLayerProps>,
-  | 'getTileData'
   | 'tileSize'
   | 'maxCacheSize'
   | 'maxCacheByteSize'
@@ -60,6 +60,7 @@ export type Tileset2DProps = Pick<
   | 'maxRequests'
   | 'zoomOffset'
 > & {
+  getTileData: NonNullable<TileLayerProps['getTileData']>;
   onTileLoad: (tile: Tile2DHeader) => void;
   onTileUnload: (tile: Tile2DHeader) => void;
   onTileError: (error: any, tile: Tile2DHeader) => void;
@@ -78,6 +79,7 @@ export default class Tileset2D {
 
   private _cacheByteSize: number;
   private _viewport: Viewport | null;
+  private _zRange?: ZRange;
   private _selectedTiles: Tile2DHeader[] | null;
   private _frameNumber: number;
   private _modelMatrix: Matrix4;
@@ -184,12 +186,18 @@ export default class Tileset2D {
   ): number {
     const modelMatrixAsMatrix4 = new Matrix4(modelMatrix);
     const isModelMatrixNew = !modelMatrixAsMatrix4.equals(this._modelMatrix);
-    if (!this._viewport || !viewport.equals(this._viewport) || isModelMatrixNew) {
+    if (
+      !this._viewport ||
+      !viewport.equals(this._viewport) ||
+      !equals(this._zRange, zRange) ||
+      isModelMatrixNew
+    ) {
       if (isModelMatrixNew) {
         this._modelMatrixInverse = modelMatrixAsMatrix4.clone().invert();
         this._modelMatrix = modelMatrixAsMatrix4;
       }
       this._viewport = viewport;
+      this._zRange = zRange;
       const tileIndices = this.getTileIndices({
         viewport,
         maxZoom: this._maxZoom,
@@ -225,6 +233,32 @@ export default class Tileset2D {
     return this._frameNumber;
   }
 
+  isTileVisible(
+    tile: Tile2DHeader,
+    cullRect?: {x: number; y: number; width: number; height: number}
+  ): boolean {
+    if (!tile.isVisible) {
+      return false;
+    }
+
+    if (cullRect && this._viewport) {
+      const [minX, minY, maxX, maxY] = getCullBounds({
+        viewport: this._viewport,
+        z: this._zRange,
+        cullRect
+      });
+      const {bbox} = tile;
+      if ('west' in bbox) {
+        return bbox.west < maxX && bbox.east > minX && bbox.south < maxY && bbox.north > minY;
+      }
+      // top/bottom could be swapped depending on the indexing system
+      const y0 = Math.min(bbox.top, bbox.bottom);
+      const y1 = Math.max(bbox.top, bbox.bottom);
+      return bbox.left < maxX && bbox.right > minX && y0 < maxY && y1 > minY;
+    }
+    return true;
+  }
+
   /* Public interface for subclassing */
 
   /** Returns array of tile indices in the current viewport */
@@ -321,7 +355,9 @@ export default class Tileset2D {
 
   /* Private methods */
 
-  _pruneRequests(): void {
+  private _getCullBounds = memoize(getCullBounds);
+
+  private _pruneRequests(): void {
     const {maxRequests} = this.opts;
 
     const abortCandidates: Tile2DHeader[] = [];
@@ -345,7 +381,7 @@ export default class Tileset2D {
   }
 
   // This needs to be called every time some tiles have been added/removed from cache
-  _rebuildTree() {
+  private _rebuildTree() {
     const {_cache} = this;
 
     // Reset states

package/src/tile-layer/utils.ts

@@ -127,6 +127,50 @@ function getBoundingBox(viewport: Viewport, zRange: number[] | null, extent: Bou
   ];
 }
 
+/** Get culling bounds in world space */
+export function getCullBounds({
+  viewport,
+  z,
+  cullRect
+}: {
+  /** Current viewport */
+  viewport: Viewport;
+  /** Current z range */
+  z: ZRange | number | undefined;
+  /** Culling rectangle in screen space */
+  cullRect: {x: number; y: number; width: number; height: number};
+}): [number, number, number, number] {
+  const x = cullRect.x - viewport.x;
+  const y = cullRect.y - viewport.y;
+  const {width, height} = cullRect;
+
+  if (!Array.isArray(z)) {
+    const unprojectOption = {targetZ: z || 0};
+
+    const topLeft = viewport.unproject([x, y], unprojectOption);
+    const topRight = viewport.unproject([x + width, y], unprojectOption);
+    const bottomLeft = viewport.unproject([x, y + height], unprojectOption);
+    const bottomRight = viewport.unproject([x + width, y + height], unprojectOption);
+
+    return [
+      Math.min(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]),
+      Math.min(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]),
+      Math.max(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]),
+      Math.max(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1])
+    ];
+  }
+
+  const bounds0 = getCullBounds({viewport, z: z[0], cullRect});
+  const bounds1 = getCullBounds({viewport, z: z[1], cullRect});
+
+  return [
+    Math.min(bounds0[0], bounds1[0]),
+    Math.min(bounds0[1], bounds1[1]),
+    Math.max(bounds0[2], bounds1[2]),
+    Math.max(bounds0[3], bounds1[3])
+  ];
+}
+
 function getIndexingCoords(bbox: Bounds, scale: number, modelMatrixInverse?: Matrix4): Bounds {
   if (modelMatrixInverse) {
     const transformedTileIndex = transformBox(bbox, modelMatrixInverse).map(

package/src/trips-layer/{trips-layer.js → trips-layer.ts}

@@ -18,16 +18,50 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-import {PathLayer} from '@deck.gl/layers';
+import type {NumericArray} from '@math.gl/core';
+import {AccessorFunction, DefaultProps} from '@deck.gl/core';
+import {PathLayer, PathLayerProps} from '@deck.gl/layers';
 
-const defaultProps = {
+const defaultProps: DefaultProps<TripsLayerProps> = {
   fadeTrail: true,
   trailLength: {type: 'number', value: 120, min: 0},
   currentTime: {type: 'number', value: 0, min: 0},
-  getTimestamps: {type: 'accessor', value: null}
+  getTimestamps: {type: 'accessor', value: d => d.timestamps}
 };
 
-export default class TripsLayer extends PathLayer {
+/** All properties supported by TripsLayer. */
+export type TripsLayerProps<DataT = any> = _TripsLayerProps<DataT> & PathLayerProps<DataT>;
+
+/** Properties added by TripsLayer. */
+type _TripsLayerProps<DataT = any> = {
+  /**
+   * Whether or not the path fades out.
+   * @default true
+   */
+  fadeTrail?: boolean;
+  /**
+   * Trail length.
+   * @default 120
+   */
+  trailLength?: number;
+  /**
+   * The current time of the frame.
+   * @default 0
+   */
+  currentTime?: number;
+  /**
+   * Timestamp accessor.
+   */
+  getTimestamps?: AccessorFunction<DataT, NumericArray>;
+};
+
+export default class TripsLayer<DataT = any, ExtraProps = {}> extends PathLayer<
+  DataT,
+  Required<_TripsLayerProps> & ExtraProps
+> {
+  static layerName = 'TripsLayer';
+  static defaultProps = defaultProps;
+
   getShaders() {
     const shaders = super.getShaders();
     shaders.inject = {
@@ -63,11 +97,11 @@ if(fadeTrail) {
     return shaders;
   }
 
-  initializeState(params) {
-    super.initializeState(params);
+  initializeState() {
+    super.initializeState();
 
     const attributeManager = this.getAttributeManager();
-    attributeManager.addInstanced({
+    attributeManager!.addInstanced({
       timestamps: {
         size: 1,
         accessor: 'getTimestamps',
@@ -96,6 +130,3 @@ if(fadeTrail) {
     super.draw(params);
   }
 }
-
-TripsLayer.layerName = 'TripsLayer';
-TripsLayer.defaultProps = defaultProps;

package/typed/geo-cell-layer/GeoCellLayer.d.ts

@@ -1,45 +1,10 @@
-import { CompositeLayer, CompositeLayerProps, Layer, LayersList } from '@deck.gl/core/typed';
+import { CompositeLayer, CompositeLayerProps, Layer, LayersList, DefaultProps } from '@deck.gl/core/typed';
 import { PolygonLayerProps } from '@deck.gl/layers/typed';
 /** All properties supported by GeoCellLayer. */
 export declare type GeoCellLayerProps<DataT = any> = PolygonLayerProps<DataT> & CompositeLayerProps<DataT>;
 export default class GeoCellLayer<DataT = any, ExtraProps = {}> extends CompositeLayer<Required<GeoCellLayerProps<DataT>> & ExtraProps> {
     static layerName: string;
-    static defaultProps: {
-        stroked: boolean;
-        filled: boolean;
-        extruded: boolean;
-        elevationScale: number;
-        wireframe: boolean;
-        _normalize: boolean;
-        _windingOrder: string;
-        lineWidthUnits: string;
-        lineWidthScale: number;
-        lineWidthMinPixels: number;
-        lineWidthMaxPixels: number;
-        lineJointRounded: boolean;
-        lineMiterLimit: number;
-        getPolygon: {
-            type: string;
-            value: (f: any) => any;
-        };
-        getFillColor: {
-            type: string;
-            value: number[];
-        };
-        getLineColor: {
-            type: string;
-            value: number[];
-        };
-        getLineWidth: {
-            type: string;
-            value: number;
-        };
-        getElevation: {
-            type: string;
-            value: number;
-        };
-        material: boolean;
-    };
+    static defaultProps: DefaultProps<GeoCellLayerProps<any>>;
     /** Implement to generate props to create geometry. */
     indexToBounds(): Partial<GeoCellLayer['props']> | null;
     renderLayers(): Layer | null | LayersList;

package/typed/geo-cell-layer/GeoCellLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GeoCellLayer.d.ts","sourceRoot":"","sources":["../../src/geo-cell-layer/GeoCellLayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAE,mBAAmB,EAAE,KAAK,EAAE,UAAU,EAAC,MAAM,eAAe,CAAC;AACrF,OAAO,EAAe,iBAAiB,EAAC,MAAM,iBAAiB,CAAC;AAMhE,gDAAgD;AAChD,oBAAY,iBAAiB,CAAC,KAAK,GAAG,GAAG,IAAI,iBAAiB,CAAC,KAAK,CAAC,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAEnG,MAAM,CAAC,OAAO,OAAO,YAAY,CAAC,KAAK,GAAG,GAAG,EAAE,UAAU,GAAG,EAAE,CAAE,SAAQ,cAAc,CACpF,QAAQ,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,GAAG,UAAU,CAChD;IACC,MAAM,CAAC,SAAS,SAAkB;IAClC,MAAM,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAgB;IAEnC,sDAAsD;IACtD,aAAa,IAAI,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI;IAItD,YAAY,IAAI,KAAK,GAAG,IAAI,GAAG,UAAU;CA+D1C"}
+{"version":3,"file":"GeoCellLayer.d.ts","sourceRoot":"","sources":["../../src/geo-cell-layer/GeoCellLayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAE,mBAAmB,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,EAAC,MAAM,eAAe,CAAC;AACnG,OAAO,EAAe,iBAAiB,EAAC,MAAM,iBAAiB,CAAC;AAMhE,gDAAgD;AAChD,oBAAY,iBAAiB,CAAC,KAAK,GAAG,GAAG,IAAI,iBAAiB,CAAC,KAAK,CAAC,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAEnG,MAAM,CAAC,OAAO,OAAO,YAAY,CAAC,KAAK,GAAG,GAAG,EAAE,UAAU,GAAG,EAAE,CAAE,SAAQ,cAAc,CACpF,QAAQ,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,GAAG,UAAU,CAChD;IACC,MAAM,CAAC,SAAS,SAAkB;IAClC,MAAM,CAAC,YAAY,uCAAgB;IAEnC,sDAAsD;IACtD,aAAa,IAAI,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI;IAItD,YAAY,IAAI,KAAK,GAAG,IAAI,GAAG,UAAU;CA+D1C"}

package/typed/geohash-layer/geohash-layer.d.ts

@@ -0,0 +1,20 @@
+import { AccessorFunction } from '@deck.gl/core/typed';
+import GeoCellLayer from '../geo-cell-layer/GeoCellLayer';
+/**
+ * Properties of `GeohashLayer`.
+ */
+declare type GeohashLayerProps<DataT = any> = {
+    /**
+     * Called for each data object to retrieve the geohash string identifier.
+     *
+     * By default, it reads `geohash` property of data object.
+     */
+    getGeohash?: AccessorFunction<DataT, string>;
+};
+export default class GeohashLayer<DataT = any, ExtraProps = {}> extends GeoCellLayer<DataT, Required<GeohashLayerProps> & ExtraProps> {
+    static layerName: string;
+    static defaultProps: any;
+    indexToBounds(): Partial<GeoCellLayer['props']> | null;
+}
+export {};
+//# sourceMappingURL=geohash-layer.d.ts.map

package/typed/geohash-layer/geohash-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geohash-layer.d.ts","sourceRoot":"","sources":["../../src/geohash-layer/geohash-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,gBAAgB,EAAC,MAAM,eAAe,CAAC;AAC/C,OAAO,YAAY,MAAM,gCAAgC,CAAC;AAO1D;;GAEG;AACH,aAAK,iBAAiB,CAAC,KAAK,GAAG,GAAG,IAAI;IACpC;;;;OAIG;IACH,UAAU,CAAC,EAAE,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CAC9C,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,YAAY,CAAC,KAAK,GAAG,GAAG,EAAE,UAAU,GAAG,EAAE,CAAE,SAAQ,YAAY,CAClF,KAAK,EACL,QAAQ,CAAC,iBAAiB,CAAC,GAAG,UAAU,CACzC;IACC,MAAM,CAAC,SAAS,SAAkB;IAClC,MAAM,CAAC,YAAY,EAAE,GAAG,CAAgB;IAExC,aAAa,IAAI,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI;CAUvD"}

package/typed/geohash-layer/geohash-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function getGeohashBounds(geohash: string): number[];
+export declare function getGeohashPolygon(geohash: string): number[];
+//# sourceMappingURL=geohash-utils.d.ts.map

package/typed/geohash-layer/geohash-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geohash-utils.d.ts","sourceRoot":"","sources":["../../src/geohash-layer/geohash-utils.ts"],"names":[],"mappings":"AAYA,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAmC1D;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAI3D"}