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

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

@@ -3,19 +3,20 @@ import {Layer, log} from '@deck.gl/core';
 import {RequestScheduler} from '@loaders.gl/loader-utils';
 import {TileBoundingBox, TileIndex, TileLoadProps} from './types';
 
-export type TileLoadDataProps = {
+export type TileLoadDataProps<DataT = any> = {
   requestScheduler: RequestScheduler;
-  getData: (props: TileLoadProps) => Promise<any>;
-  onLoad: (tile: Tile2DHeader) => void;
-  onError: (error: any, tile: Tile2DHeader) => void;
+  getData: (props: TileLoadProps) => Promise<DataT>;
+  onLoad: (tile: Tile2DHeader<DataT>) => void;
+  onError: (error: any, tile: Tile2DHeader<DataT>) => void;
 };
-export default class Tile2DHeader {
+
+export default class Tile2DHeader<DataT = any> {
   index: TileIndex;
   isVisible: boolean;
   isSelected: boolean;
   parent: Tile2DHeader | null;
   children: Tile2DHeader[] | null;
-  content: any;
+  content: DataT | null;
   state?: number;
   layers?: Layer[] | null;
 
@@ -48,24 +49,24 @@ export default class Tile2DHeader {
     this._needsReload = false;
   }
 
-  get data() {
+  get data(): Promise<DataT | null> | DataT | null {
     return this.isLoading && this._loader ? this._loader.then(() => this.data) : this.content;
   }
 
-  get isLoaded() {
+  get isLoaded(): boolean {
     return this._isLoaded && !this._needsReload;
   }
 
-  get isLoading() {
+  get isLoading(): boolean {
     return Boolean(this._loader) && !this._isCancelled;
   }
 
-  get needsReload() {
+  get needsReload(): boolean {
     return this._needsReload || this._isCancelled;
   }
 
-  get byteLength() {
-    const result = this.content ? this.content.byteLength : 0;
+  get byteLength(): number {
+    const result = this.content ? (this.content as any).byteLength : 0;
     if (!Number.isFinite(result)) {
       log.error('byteLength not defined in tile data')();
     }
@@ -78,7 +79,7 @@ export default class Tile2DHeader {
     requestScheduler,
     onLoad,
     onError
-  }: TileLoadDataProps): Promise<void> {
+  }: TileLoadDataProps<DataT>): Promise<void> {
     const {index, id, bbox, userData, zoom} = this;
     const loaderId = this._loaderId;
 
@@ -100,7 +101,7 @@ export default class Tile2DHeader {
       return;
     }
 
-    let tileData = null;
+    let tileData: DataT | null = null;
     let error;
     try {
       tileData = await getData({index, id, bbox, userData, zoom, signal});

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

@@ -1,10 +1,11 @@
 import {
-  assert,
   CompositeLayer,
   CompositeLayerProps,
   Layer,
   LayerProps,
   UpdateParameters,
+  PickingInfo,
+  GetPickingInfoParams,
   _flatten as flatten
 } from '@deck.gl/core';
 import {GeoJsonLayer} from '@deck.gl/layers';
@@ -40,7 +41,7 @@ const defaultProps = {
 };
 
 /** All props supported by the TileLayer */
-export type TileLayerProps<DataT> = _TileLayerProps<DataT> & CompositeLayerProps<DataT>;
+export type TileLayerProps<DataT = any> = _TileLayerProps<DataT> & CompositeLayerProps<DataT>;
 
 /** Props added by the TileLayer */
 type _TileLayerProps<DataT> = {
@@ -54,24 +55,24 @@ type _TileLayerProps<DataT> = {
   renderSubLayers?: (
     props: TileLayerProps<DataT> & {
       id: string;
-      data: any;
+      data: DataT;
       _offset: number;
-      tile: Tile2DHeader;
+      tile: Tile2DHeader<DataT>;
     }
-  ) => LayersList;
+  ) => Layer | null | LayersList;
   /**
    * If supplied, `getTileData` is called to retrieve the data of each tile.
    */
   getTileData?: (props: TileLoadProps) => Promise<DataT> | DataT;
 
   /** Called when all tiles in the current viewport are loaded. */
-  onViewportLoad?: (tiles: Tile2DHeader[]) => void;
+  onViewportLoad?: (tiles: Tile2DHeader<DataT>[]) => void;
 
   /** Called when a tile successfully loads. */
-  onTileLoad?: (tile: Tile2DHeader) => void;
+  onTileLoad?: (tile: Tile2DHeader<DataT>) => void;
 
   /** Called when a tile is cleared from cache. */
-  onTileUnload?: (tile: Tile2DHeader) => void;
+  onTileUnload?: (tile: Tile2DHeader<DataT>) => void;
 
   /** Called when a tile failed to load. */
   onTileError?: (err: any) => void;
@@ -129,6 +130,10 @@ type _TileLayerProps<DataT> = {
   zoomOffset?: number;
 };
 
+export type TiledPickingInfo<DataT = any> = PickingInfo & {
+  tile?: Tile2DHeader<DataT>;
+};
+
 /**
  * The TileLayer is a composite layer that makes it possible to visualize very large datasets.
  *
@@ -161,9 +166,7 @@ export default class TileLayer<DataT = any, ExtraPropsT = {}> extends CompositeL
     return changeFlags.somethingChanged;
   }
 
-  updateState({changeFlags}: UpdateParameters<TileLayer>) {
-    assert(this.state);
-
+  updateState({changeFlags}: UpdateParameters<this>) {
     let {tileset} = this.state;
     const propsChanged = changeFlags.propsOrDataChanged || changeFlags.updateTriggersChanged;
     const dataChanged =
@@ -223,8 +226,7 @@ export default class TileLayer<DataT = any, ExtraPropsT = {}> extends CompositeL
     };
   }
 
-  _updateTileset(): void {
-    assert(this.state && this.context);
+  private _updateTileset(): void {
     const {tileset} = this.state;
     const {zRange, modelMatrix} = this.props;
     const frameNumber = tileset.update(this.context.viewport, {zRange, modelMatrix});
@@ -246,8 +248,6 @@ export default class TileLayer<DataT = any, ExtraPropsT = {}> extends CompositeL
   }
 
   _onViewportLoad(): void {
-    assert(this.state);
-
     const {tileset} = this.state;
     const {onViewportLoad} = this.props;
 
@@ -256,27 +256,27 @@ export default class TileLayer<DataT = any, ExtraPropsT = {}> extends CompositeL
     }
   }
 
-  _onTileLoad(tile: Tile2DHeader): void {
+  _onTileLoad(tile: Tile2DHeader<DataT>): void {
     this.props.onTileLoad(tile);
     tile.layers = null;
 
     this.setNeedsUpdate();
   }
 
-  _onTileError(error: any, tile: Tile2DHeader) {
+  _onTileError(error: any, tile: Tile2DHeader<DataT>) {
     this.props.onTileError(error);
     tile.layers = null;
 
     this.setNeedsUpdate();
   }
 
-  _onTileUnload(tile: Tile2DHeader) {
+  _onTileUnload(tile: Tile2DHeader<DataT>) {
     this.props.onTileUnload(tile);
   }
 
   // Methods for subclass to override
 
-  getTileData(tile: TileLoadProps) {
+  getTileData(tile: TileLoadProps): Promise<DataT> | DataT | null {
     const {data, getTileData, fetch} = this.props;
     const {signal} = tile;
 
@@ -293,33 +293,32 @@ export default class TileLayer<DataT = any, ExtraPropsT = {}> extends CompositeL
   }
 
   renderSubLayers(
-    props: _TileLayerProps<DataT> & {
+    props: TileLayer['props'] & {
       id: string;
-      data: any;
+      data: DataT;
       _offset: number;
-      tile: Tile2DHeader;
+      tile: Tile2DHeader<DataT>;
     }
-  ): LayersList {
+  ): Layer | null | LayersList {
     return this.props.renderSubLayers(props);
   }
 
-  getSubLayerPropsByTile(tile: Tile2DHeader): LayerProps | null {
+  getSubLayerPropsByTile(tile: Tile2DHeader): Partial<LayerProps> | null {
     return null;
   }
 
-  getPickingInfo({info, sourceLayer}) {
-    info.tile = sourceLayer.props.tile;
+  getPickingInfo({info, sourceLayer}: GetPickingInfoParams): TiledPickingInfo<DataT> {
+    (info as any).tile = (sourceLayer as any).props.tile;
     return info;
   }
 
-  _updateAutoHighlight(info) {
+  protected _updateAutoHighlight(info: PickingInfo): void {
     if (info.sourceLayer) {
       info.sourceLayer.updateAutoHighlight(info);
     }
   }
 
-  renderLayers(): Layer[] {
-    assert(this.state);
+  renderLayers(): Layer | null | LayersList {
     return this.state.tileset.tiles.map((tile: Tile2DHeader) => {
       const subLayerProps = this.getSubLayerPropsByTile(tile);
       // cache the rendered layer in the tile
@@ -333,7 +332,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

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

@@ -2,7 +2,7 @@ import Tile2DHeader from './tile-2d-header';
 import {getTileIndices, tileToBoundingBox} from './utils';
 import {RequestScheduler} from '@loaders.gl/loader-utils';
 import {Matrix4} from '@math.gl/core';
-import {assert, Viewport} from '@deck.gl/core';
+import {Viewport} from '@deck.gl/core';
 import {Bounds, TileIndex, ZRange} from './types';
 import {TileLayerProps} from './tile-layer';
 
@@ -48,7 +48,7 @@ const STRATEGIES = {
 };
 
 export type Tileset2DProps = Pick<
-  TileLayerProps,
+  Required<TileLayerProps>,
   | 'getTileData'
   | 'tileSize'
   | 'maxCacheSize'
@@ -145,10 +145,10 @@ export default class Tileset2D {
   setOptions(opts: Tileset2DProps): void {
     Object.assign(this.opts, opts);
     if (Number.isFinite(opts.maxZoom)) {
-      this._maxZoom = Math.floor(opts.maxZoom);
+      this._maxZoom = Math.floor(opts.maxZoom as number);
     }
     if (Number.isFinite(opts.minZoom)) {
-      this._minZoom = Math.ceil(opts.minZoom);
+      this._minZoom = Math.ceil(opts.minZoom as number);
     }
   }
 
@@ -206,7 +206,7 @@ export default class Tileset2D {
       }
       // Check for needed reloads explicitly even if the view/matrix has not changed.
     } else if (this.needsReload) {
-      this._selectedTiles = this._selectedTiles!.map(tile => this._getTile(tile.index));
+      this._selectedTiles = this._selectedTiles!.map(tile => this._getTile(tile.index, true));
     }
 
     // Update tile states
@@ -270,9 +270,9 @@ export default class Tileset2D {
   }
 
   /** Returns additional metadata to add to tile, bbox by default */
-  getTileMetadata(index: TileIndex) {
-    assert(this._viewport);
+  getTileMetadata(index: TileIndex): Record<string, any> {
     const {tileSize} = this.opts;
+    // @ts-expect-error
     return {bbox: tileToBoundingBox(this._viewport, index.x, index.y, index.z, tileSize)};
   }
 
@@ -285,8 +285,7 @@ export default class Tileset2D {
   }
 
   // Returns true if any tile's visibility changed
-  updateTileStates() {
-    assert(this._selectedTiles);
+  private updateTileStates() {
     const refinementStrategy = this.opts.refinementStrategy || STRATEGY_DEFAULT;
 
     const visibilities = new Array(this._cache.size);
@@ -298,6 +297,7 @@ export default class Tileset2D {
       tile.isSelected = false;
       tile.isVisible = false;
     }
+    // @ts-expect-error called only when _selectedTiles is already defined
     for (const tile of this._selectedTiles) {
       tile.isSelected = true;
       tile.isVisible = true;
@@ -370,12 +370,12 @@ export default class Tileset2D {
    * Clear tiles that are not visible when the cache is full
    */
   /* eslint-disable complexity */
-  _resizeCache() {
-    assert(this.selectedTiles);
+  private _resizeCache() {
     const {_cache, opts} = this;
 
     const maxCacheSize =
       opts.maxCacheSize ||
+      // @ts-expect-error called only when selectedTiles is initialized
       (opts.maxCacheByteSize ? Infinity : DEFAULT_CACHE_SCALE * this.selectedTiles.length);
     const maxCacheByteSize = opts.maxCacheByteSize || Infinity;
 
@@ -405,9 +405,9 @@ export default class Tileset2D {
   }
   /* eslint-enable complexity */
 
-  _getTile(index: TileIndex, create: true): Tile2DHeader;
-  _getTile(index: TileIndex, create?: false): Tile2DHeader | undefined;
-  _getTile(index: TileIndex, create?: boolean): Tile2DHeader | undefined {
+  private _getTile(index: TileIndex, create: true): Tile2DHeader;
+  private _getTile(index: TileIndex, create?: false): Tile2DHeader | undefined;
+  private _getTile(index: TileIndex, create?: boolean): Tile2DHeader | undefined {
     const id = this.getTileId(index);
     let tile = this._cache.get(id);
     let needsReload = false;

package/src/tile-layer/types.ts

@@ -2,9 +2,11 @@ export type ZRange = [minZ: number, maxZ: number];
 
 export type Bounds = [minX: number, minY: number, maxX: number, maxY: number];
 
+export type GeoBoundingBox = {west: number; north: number; east: number; south: number};
+
 export type TileBoundingBox =
   | {left: number; top: number; right: number; bottom: number}
-  | {west: number; north: number; east: number; south: number};
+  | GeoBoundingBox;
 
 export type TileIndex = {x: number; y: number; z: number};
 
@@ -14,4 +16,6 @@ export type TileLoadProps = {
   bbox: TileBoundingBox;
   url?: string | null;
   signal?: AbortSignal;
+  userData?: Record<string, any>;
+  zoom?: number;
 };

package/src/tile-layer/utils.ts

@@ -1,7 +1,7 @@
 import {Viewport} from '@deck.gl/core';
 import {Matrix4} from '@math.gl/core';
 import {getOSMTileIndices} from './tile-2d-traversal';
-import {Bounds, TileBoundingBox, TileIndex, ZRange} from './types';
+import {Bounds, GeoBoundingBox, TileBoundingBox, TileIndex, ZRange} from './types';
 
 const TILE_SIZE = 512;
 const DEFAULT_EXTENT: Bounds = [-Infinity, -Infinity, Infinity, Infinity];
@@ -255,3 +255,12 @@ export function getTileIndices({
 export function isURLTemplate(s: string): boolean {
   return /(?=.*{z})(?=.*{x})(?=.*({y}|{-y}))/.test(s);
 }
+
+export function isGeoBoundingBox(v: any): v is GeoBoundingBox {
+  return (
+    Number.isFinite(v.west) &&
+    Number.isFinite(v.north) &&
+    Number.isFinite(v.east) &&
+    Number.isFinite(v.south)
+  );
+}

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

@@ -18,7 +18,9 @@
 // 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} from '@deck.gl/core';
+import {PathLayer, PathLayerProps} from '@deck.gl/layers';
 
 const defaultProps = {
   fadeTrail: true,
@@ -27,7 +29,39 @@ const defaultProps = {
   getTimestamps: {type: 'accessor', value: null}
 };
 
-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: any = 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

@@ -0,0 +1,47 @@
+import { CompositeLayer, CompositeLayerProps, Layer, LayersList } 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;
+    };
+    /** Implement to generate props to create geometry. */
+    indexToBounds(): Partial<GeoCellLayer['props']> | null;
+    renderLayers(): Layer | null | LayersList;
+}
+//# sourceMappingURL=GeoCellLayer.d.ts.map

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

@@ -0,0 +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"}

package/typed/geo-cell-layer/GeoCellLayer.js

@@ -0,0 +1,49 @@
+import { CompositeLayer } from '@deck.gl/core';
+import { PolygonLayer } from '@deck.gl/layers';
+const defaultProps = {
+    ...PolygonLayer.defaultProps
+};
+export default class GeoCellLayer extends CompositeLayer {
+    /** Implement to generate props to create geometry. */
+    indexToBounds() {
+        return null;
+    }
+    renderLayers() {
+        // Rendering props underlying layer
+        const { elevationScale, extruded, wireframe, filled, stroked, lineWidthUnits, lineWidthScale, lineWidthMinPixels, lineWidthMaxPixels, lineJointRounded, lineMiterLimit, lineDashJustified, getElevation, getFillColor, getLineColor, getLineWidth } = this.props;
+        // Accessor props for underlying layers
+        const { updateTriggers, material, transitions } = this.props;
+        // Filled Polygon Layer
+        const CellLayer = this.getSubLayerClass('cell', PolygonLayer);
+        return new CellLayer({
+            filled,
+            wireframe,
+            extruded,
+            elevationScale,
+            stroked,
+            lineWidthUnits,
+            lineWidthScale,
+            lineWidthMinPixels,
+            lineWidthMaxPixels,
+            lineJointRounded,
+            lineMiterLimit,
+            lineDashJustified,
+            material,
+            transitions,
+            getElevation,
+            getFillColor,
+            getLineColor,
+            getLineWidth
+        }, this.getSubLayerProps({
+            id: 'cell',
+            updateTriggers: updateTriggers && {
+                getElevation: updateTriggers.getElevation,
+                getFillColor: updateTriggers.getFillColor,
+                getLineColor: updateTriggers.getLineColor,
+                getLineWidth: updateTriggers.getLineWidth
+            }
+        }), this.indexToBounds());
+    }
+}
+GeoCellLayer.layerName = 'GeoCellLayer';
+GeoCellLayer.defaultProps = defaultProps;

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

@@ -0,0 +1,16 @@
+declare class GreatCircleLayer extends ArcLayer<any, any> {
+    constructor(...propObjects: Partial<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

@@ -0,0 +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"}

package/typed/great-circle-layer/great-circle-layer.js

@@ -0,0 +1,29 @@
+// Copyright (c) 2015 - 2017 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.
+import { ArcLayer } from '@deck.gl/layers';
+// This layer has been merged into the core ArcLayer
+// Keeping for backward-compatibility
+export default class GreatCircleLayer extends ArcLayer {
+}
+GreatCircleLayer.layerName = 'GreatCircleLayer';
+GreatCircleLayer.defaultProps = {
+    getHeight: { type: 'accessor', value: 0 },
+    greatCircle: true
+};

package/typed/h3-layers/h3-cluster-layer.d.ts

@@ -0,0 +1,16 @@
+declare class H3ClusterLayer extends GeoCellLayer<any, any> {
+    constructor(...propObjects: Partial<any>[]);
+}
+declare namespace H3ClusterLayer {
+    export { defaultProps };
+    export const layerName: string;
+}
+export default H3ClusterLayer;
+import GeoCellLayer from "../geo-cell-layer/GeoCellLayer";
+declare namespace defaultProps {
+    namespace getHexagons {
+        const type: string;
+        function value(d: any): any;
+    }
+}
+//# sourceMappingURL=h3-cluster-layer.d.ts.map

package/typed/h3-layers/h3-cluster-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"h3-cluster-layer.d.ts","sourceRoot":"","sources":["../../src/h3-layers/h3-cluster-layer.js"],"names":[],"mappings":"AASA;IASuC,4CACP;CAoB/B;;;;;;;;;;QAjCwC,4BAAe"}

package/typed/h3-layers/h3-cluster-layer.js

@@ -0,0 +1,33 @@
+import { h3SetToMultiPolygon } from 'h3-js';
+import { createIterable } from '@deck.gl/core';
+import GeoCellLayer from '../geo-cell-layer/GeoCellLayer';
+const defaultProps = {
+    getHexagons: { type: 'accessor', value: d => d.hexagons }
+};
+export default class H3ClusterLayer extends GeoCellLayer {
+    updateState({ props, oldProps, changeFlags }) {
+        if (changeFlags.dataChanged ||
+            (changeFlags.updateTriggers && changeFlags.updateTriggers.getHexagons)) {
+            const { data, getHexagons } = props;
+            const polygons = [];
+            const { iterable, objectInfo } = createIterable(data);
+            for (const object of iterable) {
+                objectInfo.index++;
+                const hexagons = getHexagons(object, objectInfo);
+                const multiPolygon = h3SetToMultiPolygon(hexagons, true);
+                for (const polygon of multiPolygon) {
+                    polygons.push(this.getSubLayerRow({ polygon }, object, objectInfo.index));
+                }
+            }
+            this.setState({ polygons });
+        }
+    }
+    indexToBounds() {
+        return {
+            data: this.state.polygons,
+            getPolygon: d => d.polygon
+        };
+    }
+}
+H3ClusterLayer.defaultProps = defaultProps;
+H3ClusterLayer.layerName = 'H3ClusterLayer';