@deck.gl/geo-layers 8.8.0-beta.1 → 8.8.0-beta.2

package/src/s2-layer/{s2-geometry.js → s2-geometry.ts}

@@ -21,24 +21,28 @@ const MAX_LEVEL = 30;
 const POS_BITS = 2 * MAX_LEVEL + 1; // 61 (60 bits of data, 1 bit lsb marker)
 const RADIAN_TO_DEGREE = 180 / Math.PI;
 
-export function IJToST(ij, order, offsets) {
+export function IJToST(
+  ij: [number, number],
+  order: number,
+  offsets: [number, number]
+): [number, number] {
   const maxSize = 1 << order;
 
   return [(ij[0] + offsets[0]) / maxSize, (ij[1] + offsets[1]) / maxSize];
 }
 
-function singleSTtoUV(st) {
+function singleSTtoUV(st: number): number {
   if (st >= 0.5) {
     return (1 / 3.0) * (4 * st * st - 1);
   }
   return (1 / 3.0) * (1 - 4 * (1 - st) * (1 - st));
 }
 
-export function STToUV(st) {
+export function STToUV(st: [number, number]): [number, number] {
   return [singleSTtoUV(st[0]), singleSTtoUV(st[1])];
 }
 
-export function FaceUVToXYZ(face, [u, v]) {
+export function FaceUVToXYZ(face: number, [u, v]: [number, number]): [number, number, number] {
   switch (face) {
     case 0:
       return [1, u, v];
@@ -57,14 +61,14 @@ export function FaceUVToXYZ(face, [u, v]) {
   }
 }
 
-export function XYZToLngLat([x, y, z]) {
+export function XYZToLngLat([x, y, z]: [number, number, number]): [number, number] {
   const lat = Math.atan2(z, Math.sqrt(x * x + y * y));
   const lng = Math.atan2(y, x);
 
   return [lng * RADIAN_TO_DEGREE, lat * RADIAN_TO_DEGREE];
 }
 
-export function toHilbertQuadkey(idS) {
+export function toHilbertQuadkey(idS: string): string {
   let bin = Long.fromString(idS, true, 10).toString(2);
 
   while (bin.length < FACE_BITS + POS_BITS) {
@@ -92,7 +96,7 @@ export function toHilbertQuadkey(idS) {
   return `${faceS}/${posS}`;
 }
 
-function rotateAndFlipQuadrant(n, point, rx, ry) {
+function rotateAndFlipQuadrant(n: number, point: [number, number], rx: number, ry: number): void {
   if (ry === 0) {
     if (rx === 1) {
       point[0] = n - 1 - point[0];
@@ -105,12 +109,16 @@ function rotateAndFlipQuadrant(n, point, rx, ry) {
   }
 }
 
-export function FromHilbertQuadKey(hilbertQuadkey) {
+export function FromHilbertQuadKey(hilbertQuadkey: string): {
+  face: number;
+  ij: [number, number];
+  level: number;
+} {
   const parts = hilbertQuadkey.split('/');
   const face = parseInt(parts[0], 10);
   const position = parts[1];
   const maxLevel = position.length;
-  const point = [0, 0];
+  const point = [0, 0] as [number, number];
   let level;
 
   for (let i = maxLevel - 1; i >= 0; i--) {

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

@@ -18,25 +18,42 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-import GeoCellLayer from '../geo-cell-layer/GeoCellLayer';
+import {AccessorFunction, DefaultProps} from '@deck.gl/core';
+import GeoCellLayer, {GeoCellLayerProps} from '../geo-cell-layer/GeoCellLayer';
 import {getS2Polygon} from './s2-utils';
 
-const defaultProps = {
+const defaultProps: DefaultProps<S2LayerProps> = {
   getS2Token: {type: 'accessor', value: d => d.token}
 };
 
-export default class S2Layer extends GeoCellLayer {
-  indexToBounds() {
+/** All properties supported by S2Layer. */
+export type S2LayerProps<DataT = any> = _S2LayerProps<DataT> & GeoCellLayerProps<DataT>;
+
+/** Properties added by S2Layer. */
+type _S2LayerProps<DataT> = {
+  /**
+   * Called for each data object to retrieve the quadkey string identifier.
+   *
+   * By default, it reads `token` property of data object.
+   */
+  getS2Token?: AccessorFunction<DataT, string>;
+};
+
+export default class S2Layer<DataT = any, ExtraProps = {}> extends GeoCellLayer<
+  DataT,
+  Required<_S2LayerProps<DataT>> & ExtraProps
+> {
+  static layerName = 'S2Layer';
+  static defaultProps = defaultProps;
+
+  indexToBounds(): Partial<GeoCellLayer['props']> | null {
     const {data, getS2Token} = this.props;
 
     return {
       data,
       _normalize: false,
       positionFormat: 'XY',
-      getPolygon: (x, objectInfo) => getS2Polygon(getS2Token(x, objectInfo))
+      getPolygon: (x: DataT, objectInfo) => getS2Polygon(getS2Token(x, objectInfo))
     };
   }
 }
-
-S2Layer.layerName = 'S2Layer';
-S2Layer.defaultProps = defaultProps;

package/src/s2-layer/{s2-utils.js → s2-utils.ts}

@@ -14,7 +14,7 @@ import Long from 'long';
  * Given an S2 token this function convert the token to 64 bit id
    https://github.com/google/s2-geometry-library-java/blob/c04b68bf3197a9c34082327eeb3aec7ab7c85da1/src/com/google/common/geometry/S2CellId.java#L439
  * */
-function getIdFromToken(token) {
+function getIdFromToken(token: string): number {
   // pad token with zeros to make the length 16
   const paddedToken = token.padEnd(16, '0');
   return Long.fromString(paddedToken, 16);
@@ -24,7 +24,15 @@ const MAX_RESOLUTION = 100;
 
 /* Adapted from s2-geometry's S2Cell.getCornerLatLngs */
 /* eslint-disable max-statements */
-function getGeoBounds({face, ij, level}) {
+function getGeoBounds({
+  face,
+  ij,
+  level
+}: {
+  face: number;
+  ij: [number, number];
+  level: number;
+}): Float64Array {
   const offsets = [
     [0, 0],
     [0, 1],
@@ -44,7 +52,7 @@ function getGeoBounds({face, ij, level}) {
   let prevLng = 0;
 
   for (let i = 0; i < 4; i++) {
-    const offset = offsets[i].slice(0);
+    const offset = offsets[i].slice(0) as [number, number];
     const nextOffset = offsets[i + 1];
     const stepI = (nextOffset[0] - offset[0]) / resolution;
     const stepJ = (nextOffset[1] - offset[1]) / resolution;
@@ -78,7 +86,7 @@ function getGeoBounds({face, ij, level}) {
 }
 /* eslint-enable max-statements */
 
-export function getS2QuadKey(token) {
+export function getS2QuadKey(token: string | number): string {
   if (typeof token === 'string') {
     if (token.indexOf('/') > 0) {
       // is Hilbert quad key
@@ -94,11 +102,10 @@ export function getS2QuadKey(token) {
 /**
  * Get a polygon with corner coordinates for an s2 cell
  * @param {*} cell - This can be an S2 key or token
- * @return {Array} - a simple polygon in array format: [[lng, lat], ...]
- *   - each coordinate is an array [lng, lat]
+ * @return {Float64Array} - a simple polygon in flat array format: [lng0, lat0, lng1, lat1, ...]
  *   - the polygon is closed, i.e. last coordinate is a copy of the first coordinate
  */
-export function getS2Polygon(token) {
+export function getS2Polygon(token: string | number): Float64Array {
   const key = getS2QuadKey(token);
   const s2cell = FromHilbertQuadKey(key);
 

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,7 @@ import {
   UpdateParameters,
   PickingInfo,
   GetPickingInfoParams,
+  DefaultProps,
   _flatten as flatten
 } from '@deck.gl/core';
 import {GeoJsonLayer} from '@deck.gl/layers';
@@ -16,9 +17,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 +42,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 +64,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;

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

@@ -49,7 +49,6 @@ const STRATEGIES = {
 
 export type Tileset2DProps = Pick<
   Required<TileLayerProps>,
-  | 'getTileData'
   | 'tileSize'
   | 'maxCacheSize'
   | 'maxCacheByteSize'
@@ -60,6 +59,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;

package/src/trips-layer/trips-layer.ts

@@ -19,14 +19,14 @@
 // THE SOFTWARE.
 
 import type {NumericArray} from '@math.gl/core';
-import {AccessorFunction} from '@deck.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}
 };
 
 /** All properties supported by TripsLayer. */
@@ -60,7 +60,7 @@ export default class TripsLayer<DataT = any, ExtraProps = {}> extends PathLayer<
   Required<_TripsLayerProps> & ExtraProps
 > {
   static layerName = 'TripsLayer';
-  static defaultProps: any = defaultProps;
+  static defaultProps = defaultProps;
 
   getShaders() {
     const shaders = super.getShaders();

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/great-circle-layer/great-circle-layer.d.ts

@@ -1,16 +1,9 @@
-declare class GreatCircleLayer extends ArcLayer<any, any> {
-    constructor(...propObjects: Partial<any>[]);
+import { ArcLayer, ArcLayerProps } from '@deck.gl/layers/typed';
+/** All properties supported by GreatCircleLayer. */
+export declare type GreatCircleLayerProps<DataT = any> = ArcLayerProps<DataT>;
+/** @deprecated Use ArcLayer with `greatCircle: true` instead */
+export default class GreatCircleLayer<DataT = any, ExtraProps = {}> extends ArcLayer<DataT, ExtraProps> {
+    static layerName: string;
+    static defaultProps: any;
 }
-declare namespace GreatCircleLayer {
-    const layerName: string;
-    namespace defaultProps {
-        namespace getHeight {
-            const type: string;
-            const value: number;
-        }
-        const greatCircle: boolean;
-    }
-}
-export default GreatCircleLayer;
-import { ArcLayer } from '@deck.gl/layers/typed';
 //# sourceMappingURL=great-circle-layer.d.ts.map

package/typed/great-circle-layer/great-circle-layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"great-circle-layer.d.ts","sourceRoot":"","sources":["../../src/great-circle-layer/great-circle-layer.js"],"names":[],"mappings":"AAwBA;IAfmE,4CAC1B;CAcgB"}
+{"version":3,"file":"great-circle-layer.d.ts","sourceRoot":"","sources":["../../src/great-circle-layer/great-circle-layer.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAC,QAAQ,EAAE,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAOxD,oDAAoD;AACpD,oBAAY,qBAAqB,CAAC,KAAK,GAAG,GAAG,IAAI,aAAa,CAAC,KAAK,CAAC,CAAC;AAItE,gEAAgE;AAChE,MAAM,CAAC,OAAO,OAAO,gBAAgB,CAAC,KAAK,GAAG,GAAG,EAAE,UAAU,GAAG,EAAE,CAAE,SAAQ,QAAQ,CAClF,KAAK,EACL,UAAU,CACX;IACC,MAAM,CAAC,SAAS,SAAsB;IACtC,MAAM,CAAC,YAAY,EAAE,GAAG,CAAgB;CACzC"}