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

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

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

@@ -0,0 +1,15 @@
+declare class GreatCircleLayer extends ArcLayer {
+}
+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;CAAyD"}

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;IAUW,4CACa;CAmBvB;;;;;;;;;;QAjCwC,4BAAe"}

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

@@ -0,0 +1,107 @@
+export function normalizeLongitudes(vertices: any, refLng: any): void;
+export function scalePolygon(hexId: any, vertices: any, factor: any): void;
+/**
+ * A subclass of HexagonLayer that uses H3 hexagonIds in data objects
+ * rather than centroid lat/longs. The shape of each hexagon is determined
+ * based on a single "center" hexagon, which can be selected by passing in
+ * a center lat/lon pair. If not provided, the map center will be used.
+ *
+ * Also sets the `hexagonId` field in the onHover/onClick callback's info
+ * objects. Since this is calculated using math, hexagonId will be present
+ * even when no corresponding hexagon is in the data set. You can check
+ * index !== -1 to see if picking matches an actual object.
+ */
+declare class H3HexagonLayer extends CompositeLayer<any> {
+    constructor(...propObjects: Partial<any>[]);
+    _calculateH3DataProps(props: any): {
+        resolution: number;
+        edgeLengthKM: number;
+        hasMultipleRes: boolean;
+        hasPentagon: boolean;
+    };
+    _shouldUseHighPrecision(): any;
+    _updateVertices(viewport: any): void;
+    _getForwardProps(): {
+        elevationScale: any;
+        extruded: any;
+        coverage: any;
+        wireframe: any;
+        stroked: any;
+        filled: any;
+        lineWidthUnits: any;
+        lineWidthScale: any;
+        lineWidthMinPixels: any;
+        lineWidthMaxPixels: any;
+        material: any;
+        getElevation: any;
+        getFillColor: any;
+        getLineColor: any;
+        getLineWidth: any;
+        transitions: any;
+        updateTriggers: {
+            getFillColor: any;
+            getElevation: any;
+            getLineColor: any;
+            getLineWidth: any;
+        };
+    };
+    _renderPolygonLayer(): PolygonLayer<any, {}>;
+    _renderColumnLayer(): ColumnLayer;
+}
+declare namespace H3HexagonLayer {
+    export { defaultProps };
+    export const layerName: string;
+}
+export default H3HexagonLayer;
+import { CompositeLayer } from '@deck.gl/core/typed';
+import { PolygonLayer } from '@deck.gl/layers/typed';
+import { ColumnLayer } from '@deck.gl/layers/typed';
+declare const defaultProps: {
+    highPrecision: string;
+    coverage: {
+        type: string;
+        min: number;
+        max: number;
+        value: number;
+    };
+    centerHexagon: null;
+    getHexagon: {
+        type: string;
+        value: (x: any) => any;
+    };
+    extruded: boolean;
+    stroked: boolean;
+    filled: 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;
+};
+//# sourceMappingURL=h3-hexagon-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"h3-hexagon-layer.d.ts","sourceRoot":"","sources":["../../src/h3-layers/h3-hexagon-layer.js"],"names":[],"mappings":"AAoBA,sEAUC;AAGD,2EAcC;AAwDD;;;;;;;;;;GAUG;AACH;IA/FkB,4CAAoD;IAmHpE;;;;;MA8BC;IAED,+BAUC;IAED,qCAqCC;IAMD;;;;;;;;;;;;;;;;;;;;;;;MA6CC;IAED,6CAyBC;IAED,kCAsBC;CACF;;;;;;;;;AAnOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOE"}

package/typed/index.d.ts

@@ -0,0 +1,19 @@
+export { default as GreatCircleLayer } from './great-circle-layer/great-circle-layer';
+export { default as S2Layer } from './s2-layer/s2-layer';
+export { default as QuadkeyLayer } from './quadkey-layer/quadkey-layer';
+export { default as TileLayer } from './tile-layer/tile-layer';
+export { default as TripsLayer } from './trips-layer/trips-layer';
+export { default as H3ClusterLayer } from './h3-layers/h3-cluster-layer';
+export { default as H3HexagonLayer } from './h3-layers/h3-hexagon-layer';
+export { default as Tile3DLayer } from './tile-3d-layer/tile-3d-layer';
+export { default as TerrainLayer } from './terrain-layer/terrain-layer';
+export { default as MVTLayer } from './mvt-layer/mvt-layer';
+export { getURLFromTemplate as _getURLFromTemplate } from './tile-layer/utils';
+export { default as _Tileset2D } from './tile-layer/tileset-2d';
+export { default as _Tile2DHeader } from './tile-layer/tile-2d-header';
+export type { TileLayerProps } from './tile-layer/tile-layer';
+export type { GeoBoundingBox } from './tile-layer/types';
+export type { QuadkeyLayerProps } from './quadkey-layer/quadkey-layer';
+export type { TileLoadProps as _TileLoadProps } from './tile-layer/types';
+export type { MVTLayerProps } from './mvt-layer/mvt-layer';
+//# sourceMappingURL=index.d.ts.map

package/typed/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAC,OAAO,IAAI,gBAAgB,EAAC,MAAM,yCAAyC,CAAC;AACpF,OAAO,EAAC,OAAO,IAAI,OAAO,EAAC,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAC,OAAO,IAAI,cAAc,EAAC,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAC,OAAO,IAAI,cAAc,EAAC,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAC,OAAO,IAAI,WAAW,EAAC,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAC,OAAO,IAAI,QAAQ,EAAC,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAC,kBAAkB,IAAI,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AAC7E,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAC,OAAO,IAAI,aAAa,EAAC,MAAM,6BAA6B,CAAC;AAGrE,YAAY,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAC5D,YAAY,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACvD,YAAY,EAAC,iBAAiB,EAAC,MAAM,+BAA+B,CAAC;AACrE,YAAY,EAAC,aAAa,IAAI,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACxE,YAAY,EAAC,aAAa,EAAC,MAAM,uBAAuB,CAAC"}

package/typed/mesh-layer/mesh-layer-fragment.glsl.d.ts

@@ -0,0 +1,3 @@
+declare var _default: "#version 300 es\n#define SHADER_NAME simple-mesh-layer-fs\n\nprecision highp float;\n\nuniform bool hasTexture;\nuniform sampler2D sampler;\nuniform bool flatShading;\nuniform float opacity;\n\nin vec2 vTexCoord;\nin vec3 cameraPosition;\nin vec3 normals_commonspace;\nin vec4 position_commonspace;\nin vec4 vColor;\n\nout vec4 fragColor;\n\nvoid main(void) {\n  \n#ifdef MODULE_PBR\n\n  fragColor = vColor * pbr_filterColor(vec4(0));\n  geometry.uv = pbr_vUV;\n  fragColor.a *= opacity;\n\n#else\n\n  geometry.uv = vTexCoord;\n\n  vec3 normal;\n  if (flatShading) {\n\n// NOTE(Tarek): This is necessary because\n// headless.gl reports the extension as\n// available but does not support it in\n// the shader.\n#ifdef DERIVATIVES_AVAILABLE\n    normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));\n#else\n    normal = vec3(0.0, 0.0, 1.0);\n#endif\n  } else {\n    normal = normals_commonspace;\n  }\n\n  vec4 color = hasTexture ? texture(sampler, vTexCoord) : vColor;\n  vec3 lightColor = lighting_getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);\n  fragColor = vec4(lightColor, color.a * opacity);\n\n#endif\n\n  DECKGL_FILTER_COLOR(fragColor, geometry);\n}\n";
+export default _default;
+//# sourceMappingURL=mesh-layer-fragment.glsl.d.ts.map

package/typed/mesh-layer/mesh-layer-fragment.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-layer-fragment.glsl.d.ts","sourceRoot":"","sources":["../../src/mesh-layer/mesh-layer-fragment.glsl.js"],"names":[],"mappings":""}

package/typed/mesh-layer/mesh-layer-vertex.glsl.d.ts

@@ -0,0 +1,3 @@
+declare var _default: "#version 300 es\n#define SHADER_NAME simple-mesh-layer-vs\n\n// Scale the model\nuniform float sizeScale;\nuniform bool composeModelMatrix;\nuniform bool u_pickFeatureIds;\n\n// Primitive attributes\nin vec3 positions;\nin vec3 normals;\nin vec3 colors;\nin vec2 texCoords;\nin vec4 uvRegions;\nin vec3 featureIdsPickingColors;\n\n// Instance attributes\nin vec4 instanceColors;\nin vec3 instancePickingColors;\nin mat3 instanceModelMatrix;\n\n// Outputs to fragment shader\nout vec2 vTexCoord;\nout vec3 cameraPosition;\nout vec3 normals_commonspace;\nout vec4 position_commonspace;\nout vec4 vColor;\n\nvec2 applyUVRegion(vec2 uv) {\n  #ifdef HAS_UV_REGIONS\n    // https://github.com/Esri/i3s-spec/blob/master/docs/1.7/geometryUVRegion.cmn.md\n    return fract(uv) * (uvRegions.zw - uvRegions.xy) + uvRegions.xy;\n  #else\n    return uv;\n  #endif\n}\n\nvoid main(void) {\n  vec2 uv = applyUVRegion(texCoords);\n  geometry.uv = uv;\n\n  if (u_pickFeatureIds) {\n    geometry.pickingColor = featureIdsPickingColors;\n  } else {\n    geometry.pickingColor = instancePickingColors;\n  }\n\n  vTexCoord = uv;\n  cameraPosition = project_uCameraPosition;\n  vColor = vec4(colors * instanceColors.rgb, instanceColors.a);\n\n  vec3 pos = (instanceModelMatrix * positions) * sizeScale;\n  vec3 projectedPosition = project_position(positions);\n  position_commonspace = vec4(projectedPosition, 1.0);\n  gl_Position = project_common_position_to_clipspace(position_commonspace);\n\n  geometry.position = position_commonspace;\n  normals_commonspace = project_normal(instanceModelMatrix * normals);\n  geometry.normal = normals_commonspace;\n\n  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n\n  #ifdef MODULE_PBR\n    // set PBR data\n    pbr_vPosition = geometry.position.xyz;\n    #ifdef HAS_NORMALS\n      pbr_vNormal = geometry.normal;\n    #endif\n\n    #ifdef HAS_UV\n      pbr_vUV = uv;\n    #else\n      pbr_vUV = vec2(0., 0.);\n    #endif\n    geometry.uv = pbr_vUV;\n  #endif\n\n  DECKGL_FILTER_COLOR(vColor, geometry);\n}\n";
+export default _default;
+//# sourceMappingURL=mesh-layer-vertex.glsl.d.ts.map

package/typed/mesh-layer/mesh-layer-vertex.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-layer-vertex.glsl.d.ts","sourceRoot":"","sources":["../../src/mesh-layer/mesh-layer-vertex.glsl.js"],"names":[],"mappings":""}

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

@@ -0,0 +1,27 @@
+declare class _MeshLayer extends SimpleMeshLayer<any, any> {
+    constructor(...propObjects: Partial<any>[]);
+    updatePbrMaterialUniforms(pbrMaterial: any): void;
+    parseMaterial(pbrMaterial: any, mesh: any): GLTFMaterialParser;
+    calculateFeatureIdsPickingColors(attribute: any): void;
+}
+declare namespace _MeshLayer {
+    export const layerName: string;
+    export { defaultProps };
+}
+export default _MeshLayer;
+import { SimpleMeshLayer } from '@deck.gl/mesh-layers/typed';
+import { GLTFMaterialParser } from "@luma.gl/experimental";
+declare namespace defaultProps {
+    namespace pbrMaterial {
+        const type: string;
+        const value: null;
+    }
+    namespace featureIds {
+        const type_1: string;
+        export { type_1 as type };
+        const value_1: null;
+        export { value_1 as value };
+        export const optional: boolean;
+    }
+}
+//# sourceMappingURL=mesh-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-layer.d.ts","sourceRoot":"","sources":["../../src/mesh-layer/mesh-layer.js"],"names":[],"mappings":"AAqBA;IAJO,4CACM;IAqEX,kDAOC;IAED,+DAaC;IAED,uDAcC;CACF"}

package/typed/mvt-layer/coordinate-transform.d.ts

@@ -0,0 +1,4 @@
+import { Viewport } from '@deck.gl/core/typed';
+import { GeoBoundingBox } from '../tile-layer/types';
+export declare function transform(geometry: any, bbox: GeoBoundingBox, viewport: Viewport): any;
+//# sourceMappingURL=coordinate-transform.d.ts.map