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

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

@@ -0,0 +1,118 @@
+import { CompositeLayer, CompositeLayerProps, Layer, LayerProps, UpdateParameters, PickingInfo, GetPickingInfoParams } from '@deck.gl/core/typed';
+import { LayersList } from 'modules/core/src/lib/layer-manager';
+import Tile2DHeader from './tile-2d-header';
+import Tileset2D, { RefinementStrategy, Tileset2DProps } from './tileset-2d';
+import { TileLoadProps, ZRange } from './types';
+/** All props supported by the TileLayer */
+export declare type TileLayerProps<DataT = any> = CompositeLayerProps<any> & _TileLayerProps<DataT>;
+/** Props added by the TileLayer */
+declare type _TileLayerProps<DataT> = {
+    /**
+     * Optionally implement a custom indexing scheme.
+     */
+    TilesetClass: typeof Tileset2D;
+    /**
+     * Renders one or an array of Layer instances.
+     */
+    renderSubLayers?: (props: TileLayerProps<DataT> & {
+        id: string;
+        data: DataT;
+        _offset: number;
+        tile: Tile2DHeader<DataT>;
+    }) => Layer | null | LayersList;
+    /**
+     * If supplied, `getTileData` is called to retrieve the data of each tile.
+     */
+    getTileData?: ((props: TileLoadProps) => Promise<DataT> | DataT) | null;
+    /** Called when all tiles in the current viewport are loaded. */
+    onViewportLoad?: ((tiles: Tile2DHeader<DataT>[]) => void) | null;
+    /** Called when a tile successfully loads. */
+    onTileLoad?: (tile: Tile2DHeader<DataT>) => void;
+    /** Called when a tile is cleared from cache. */
+    onTileUnload?: (tile: Tile2DHeader<DataT>) => void;
+    /** Called when a tile failed to load. */
+    onTileError?: (err: any) => void;
+    /** The bounding box of the layer's data. */
+    extent?: number[] | null;
+    /** The pixel dimension of the tiles, usually a power of 2. */
+    tileSize?: number;
+    /** The max zoom level of the layer's data.
+     * @default null
+     */
+    maxZoom?: number | null;
+    /** The min zoom level of the layer's data.
+     * @default 0
+     */
+    minZoom?: number | null;
+    /** The maximum number of tiles that can be cached. */
+    maxCacheSize?: number | null;
+    /**
+     * The maximum memory used for caching tiles.
+     *
+     * @default null
+     */
+    maxCacheByteSize?: number | null;
+    /**
+     * How the tile layer refines the visibility of tiles.
+     *
+     * @default 'best-available'
+     */
+    refinementStrategy?: RefinementStrategy;
+    /** Range of minimum and maximum heights in the tile. */
+    zRange?: ZRange | null;
+    /**
+     * The maximum number of concurrent getTileData calls.
+     *
+     * @default 6
+     */
+    maxRequests?: number;
+    /**
+     * This offset changes the zoom level at which the tiles are fetched.
+     *
+     * Needs to be an integer.
+     *
+     * @default 0
+     */
+    zoomOffset?: number;
+};
+export declare type TiledPickingInfo<DataT = any> = PickingInfo & {
+    tile?: Tile2DHeader<DataT>;
+};
+/**
+ * The TileLayer is a composite layer that makes it possible to visualize very large datasets.
+ *
+ * Instead of fetching the entire dataset, it only loads and renders what's visible in the current viewport.
+ */
+export default class TileLayer<DataT = any, ExtraPropsT = {}> extends CompositeLayer<ExtraPropsT & Required<_TileLayerProps<DataT>>> {
+    static defaultProps: any;
+    static layerName: string;
+    initializeState(): void;
+    finalizeState(): void;
+    get isLoaded(): boolean;
+    shouldUpdateState({ changeFlags }: {
+        changeFlags: any;
+    }): boolean;
+    updateState({ changeFlags }: UpdateParameters<this>): void;
+    _getTilesetOptions(): Tileset2DProps;
+    private _updateTileset;
+    _onViewportLoad(): void;
+    _onTileLoad(tile: Tile2DHeader<DataT>): void;
+    _onTileError(error: any, tile: Tile2DHeader<DataT>): void;
+    _onTileUnload(tile: Tile2DHeader<DataT>): void;
+    getTileData(tile: TileLoadProps): Promise<DataT> | DataT | null;
+    renderSubLayers(props: TileLayer['props'] & {
+        id: string;
+        data: DataT;
+        _offset: number;
+        tile: Tile2DHeader<DataT>;
+    }): Layer | null | LayersList;
+    getSubLayerPropsByTile(tile: Tile2DHeader): Partial<LayerProps> | null;
+    getPickingInfo({ info, sourceLayer }: GetPickingInfoParams): TiledPickingInfo<DataT>;
+    protected _updateAutoHighlight(info: PickingInfo): void;
+    renderLayers(): Layer | null | LayersList;
+    filterSubLayer({ layer }: {
+        layer: any;
+    }): any;
+}
+export {};
+//# sourceMappingURL=tile-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tile-layer.d.ts","sourceRoot":"","sources":["../../src/tile-layer/tile-layer.ts"],"names":[],"mappings":"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"}

package/typed/tile-layer/tile-layer.js

@@ -0,0 +1,192 @@
+import { CompositeLayer, _flatten as flatten } from '@deck.gl/core';
+import { GeoJsonLayer } from '@deck.gl/layers';
+import Tileset2D, { STRATEGY_DEFAULT } from './tileset-2d';
+import { urlType, getURLFromTemplate } from './utils';
+const defaultProps = {
+    TilesetClass: Tileset2D,
+    data: [],
+    dataComparator: urlType.equals,
+    renderSubLayers: { type: 'function', value: props => new GeoJsonLayer(props), compare: false },
+    getTileData: { type: 'function', optional: true, value: null, compare: false },
+    // TODO - change to onViewportLoad to align with Tile3DLayer
+    onViewportLoad: { type: 'function', optional: true, value: null, compare: false },
+    onTileLoad: { type: 'function', value: tile => { }, compare: false },
+    onTileUnload: { type: 'function', value: tile => { }, compare: false },
+    // eslint-disable-next-line
+    onTileError: { type: 'function', value: err => console.error(err), compare: false },
+    extent: { type: 'array', optional: true, value: null, compare: true },
+    tileSize: 512,
+    maxZoom: null,
+    minZoom: 0,
+    maxCacheSize: null,
+    maxCacheByteSize: null,
+    refinementStrategy: STRATEGY_DEFAULT,
+    zRange: null,
+    maxRequests: 6,
+    zoomOffset: 0
+};
+/**
+ * The TileLayer is a composite layer that makes it possible to visualize very large datasets.
+ *
+ * Instead of fetching the entire dataset, it only loads and renders what's visible in the current viewport.
+ */
+export default class TileLayer extends CompositeLayer {
+    initializeState() {
+        this.state = {
+            tileset: null,
+            isLoaded: false
+        };
+    }
+    finalizeState() {
+        this.state?.tileset?.finalize();
+    }
+    get isLoaded() {
+        return this.state?.tileset?.selectedTiles.every(tile => tile.isLoaded && tile.layers && tile.layers.every(layer => layer.isLoaded));
+    }
+    shouldUpdateState({ changeFlags }) {
+        return changeFlags.somethingChanged;
+    }
+    updateState({ changeFlags }) {
+        let { tileset } = this.state;
+        const propsChanged = changeFlags.propsOrDataChanged || changeFlags.updateTriggersChanged;
+        const dataChanged = changeFlags.dataChanged ||
+            (changeFlags.updateTriggersChanged &&
+                (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getTileData));
+        if (!tileset) {
+            tileset = new this.props.TilesetClass(this._getTilesetOptions());
+            this.setState({ tileset });
+        }
+        else if (propsChanged) {
+            tileset.setOptions(this._getTilesetOptions());
+            if (dataChanged) {
+                // reload all tiles
+                // use cached layers until new content is loaded
+                tileset.reloadAll();
+            }
+            else {
+                // some render options changed, regenerate sub layers now
+                this.state.tileset.tiles.forEach(tile => {
+                    tile.layers = null;
+                });
+            }
+        }
+        this._updateTileset();
+    }
+    _getTilesetOptions() {
+        const { tileSize, maxCacheSize, maxCacheByteSize, refinementStrategy, extent, maxZoom, minZoom, maxRequests, zoomOffset } = this.props;
+        return {
+            maxCacheSize,
+            maxCacheByteSize,
+            maxZoom,
+            minZoom,
+            tileSize,
+            refinementStrategy,
+            extent,
+            maxRequests,
+            zoomOffset,
+            getTileData: this.getTileData.bind(this),
+            onTileLoad: this._onTileLoad.bind(this),
+            onTileError: this._onTileError.bind(this),
+            onTileUnload: this._onTileUnload.bind(this)
+        };
+    }
+    _updateTileset() {
+        const { tileset } = this.state;
+        const { zRange, modelMatrix } = this.props;
+        const frameNumber = tileset.update(this.context.viewport, { zRange, modelMatrix });
+        const { isLoaded } = tileset;
+        const loadingStateChanged = this.state.isLoaded !== isLoaded;
+        const tilesetChanged = this.state.frameNumber !== frameNumber;
+        if (isLoaded && (loadingStateChanged || tilesetChanged)) {
+            this._onViewportLoad();
+        }
+        if (tilesetChanged) {
+            // Save the tileset frame number - trigger a rerender
+            this.setState({ frameNumber });
+        }
+        // Save the loaded state - should not trigger a rerender
+        this.state.isLoaded = isLoaded;
+    }
+    _onViewportLoad() {
+        const { tileset } = this.state;
+        const { onViewportLoad } = this.props;
+        if (onViewportLoad) {
+            onViewportLoad(tileset.selectedTiles);
+        }
+    }
+    _onTileLoad(tile) {
+        this.props.onTileLoad(tile);
+        tile.layers = null;
+        this.setNeedsUpdate();
+    }
+    _onTileError(error, tile) {
+        this.props.onTileError(error);
+        tile.layers = null;
+        this.setNeedsUpdate();
+    }
+    _onTileUnload(tile) {
+        this.props.onTileUnload(tile);
+    }
+    // Methods for subclass to override
+    getTileData(tile) {
+        const { data, getTileData, fetch } = this.props;
+        const { signal } = tile;
+        tile.url =
+            typeof data === 'string' || Array.isArray(data) ? getURLFromTemplate(data, tile) : null;
+        if (getTileData) {
+            return getTileData(tile);
+        }
+        if (fetch && tile.url) {
+            return fetch(tile.url, { propName: 'data', layer: this, signal });
+        }
+        return null;
+    }
+    renderSubLayers(props) {
+        return this.props.renderSubLayers(props);
+    }
+    getSubLayerPropsByTile(tile) {
+        return null;
+    }
+    getPickingInfo({ info, sourceLayer }) {
+        info.tile = sourceLayer.props.tile;
+        return info;
+    }
+    _updateAutoHighlight(info) {
+        if (info.sourceLayer) {
+            info.sourceLayer.updateAutoHighlight(info);
+        }
+    }
+    renderLayers() {
+        return this.state.tileset.tiles.map((tile) => {
+            const subLayerProps = this.getSubLayerPropsByTile(tile);
+            // cache the rendered layer in the tile
+            if (!tile.isLoaded && !tile.content) {
+                // nothing to show
+            }
+            else if (!tile.layers) {
+                const layers = this.renderSubLayers({
+                    ...this.props,
+                    id: `${this.id}-${tile.id}`,
+                    data: tile.content,
+                    _offset: 0,
+                    tile
+                });
+                tile.layers = flatten(layers, Boolean).map(layer => layer.clone({
+                    tile,
+                    ...subLayerProps
+                }));
+            }
+            else if (subLayerProps &&
+                tile.layers[0] &&
+                Object.keys(subLayerProps).some(propName => tile.layers[0].props[propName] !== subLayerProps[propName])) {
+                tile.layers = tile.layers.map(layer => layer.clone(subLayerProps));
+            }
+            return tile.layers;
+        });
+    }
+    filterSubLayer({ layer }) {
+        return layer.props.tile.isVisible;
+    }
+}
+TileLayer.defaultProps = defaultProps;
+TileLayer.layerName = 'TileLayer';

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

@@ -0,0 +1,88 @@
+import Tile2DHeader from './tile-2d-header';
+import { Matrix4 } from '@math.gl/core';
+import { Viewport } from '@deck.gl/core/typed';
+import { TileIndex, ZRange } from './types';
+import { TileLayerProps } from './tile-layer';
+export declare const STRATEGY_NEVER = "never";
+export declare const STRATEGY_REPLACE = "no-overlap";
+export declare const STRATEGY_DEFAULT = "best-available";
+export declare type RefinementStrategyFunction = (tiles: Tile2DHeader[]) => void;
+export declare type RefinementStrategy = typeof STRATEGY_NEVER | typeof STRATEGY_REPLACE | typeof STRATEGY_DEFAULT | RefinementStrategyFunction;
+export declare type Tileset2DProps = Pick<Required<TileLayerProps>, 'tileSize' | 'maxCacheSize' | 'maxCacheByteSize' | 'refinementStrategy' | 'extent' | 'maxZoom' | 'minZoom' | 'maxRequests' | 'zoomOffset'> & {
+    getTileData: NonNullable<TileLayerProps['getTileData']>;
+    onTileLoad: (tile: Tile2DHeader) => void;
+    onTileUnload: (tile: Tile2DHeader) => void;
+    onTileError: (error: any, tile: Tile2DHeader) => void;
+};
+/**
+ * Manages loading and purging of tile data. This class caches recently visited tiles
+ * and only creates new tiles if they are present.
+ */
+export default class Tileset2D {
+    private opts;
+    private _requestScheduler;
+    private _cache;
+    private _dirty;
+    private _tiles;
+    private _cacheByteSize;
+    private _viewport;
+    private _selectedTiles;
+    private _frameNumber;
+    private _modelMatrix;
+    private _modelMatrixInverse;
+    private _maxZoom?;
+    private _minZoom?;
+    private onTileLoad;
+    /**
+     * Takes in a function that returns tile data, a cache size, and a max and a min zoom level.
+     * Cache size defaults to 5 * number of tiles in the current viewport
+     */
+    constructor(opts: Tileset2DProps);
+    get tiles(): Tile2DHeader<any>[];
+    get selectedTiles(): Tile2DHeader[] | null;
+    get isLoaded(): boolean;
+    get needsReload(): boolean;
+    setOptions(opts: Tileset2DProps): void;
+    finalize(): void;
+    reloadAll(): void;
+    /**
+     * Update the cache with the given viewport and model matrix and triggers callback onUpdate.
+     */
+    update(viewport: Viewport, { zRange, modelMatrix }?: {
+        zRange?: ZRange;
+        modelMatrix?: Matrix4;
+    }): number;
+    /** Returns array of tile indices in the current viewport */
+    getTileIndices({ viewport, maxZoom, minZoom, zRange, modelMatrix, modelMatrixInverse }: {
+        viewport: Viewport;
+        maxZoom?: number;
+        minZoom?: number;
+        zRange: ZRange | undefined;
+        tileSize?: number;
+        modelMatrix?: Matrix4;
+        modelMatrixInverse?: Matrix4;
+        zoomOffset?: number;
+    }): TileIndex[];
+    /** Returns unique string key for a tile index */
+    getTileId(index: TileIndex): string;
+    /** Returns a zoom level for a tile index */
+    getTileZoom(index: TileIndex): number;
+    /** Returns additional metadata to add to tile, bbox by default */
+    getTileMetadata(index: TileIndex): Record<string, any>;
+    /** Returns index of the parent tile */
+    getParentIndex(index: TileIndex): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    private updateTileStates;
+    _pruneRequests(): void;
+    _rebuildTree(): void;
+    /**
+     * Clear tiles that are not visible when the cache is full
+     */
+    private _resizeCache;
+    private _getTile;
+    _getNearestAncestor(tile: Tile2DHeader): Tile2DHeader | null;
+}
+//# sourceMappingURL=tileset-2d.d.ts.map

package/typed/tile-layer/tileset-2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tileset-2d.d.ts","sourceRoot":"","sources":["../../src/tile-layer/tileset-2d.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,kBAAkB,CAAC;AAG5C,OAAO,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AACtC,OAAO,EAAC,QAAQ,EAAC,MAAM,eAAe,CAAC;AACvC,OAAO,EAAS,SAAS,EAAE,MAAM,EAAC,MAAM,SAAS,CAAC;AAClD,OAAO,EAAC,cAAc,EAAC,MAAM,cAAc,CAAC;AAwB5C,eAAO,MAAM,cAAc,UAAU,CAAC;AACtC,eAAO,MAAM,gBAAgB,eAAe,CAAC;AAC7C,eAAO,MAAM,gBAAgB,mBAAmB,CAAC;AAEjD,oBAAY,0BAA0B,GAAG,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,IAAI,CAAC;AACzE,oBAAY,kBAAkB,GAC1B,OAAO,cAAc,GACrB,OAAO,gBAAgB,GACvB,OAAO,gBAAgB,GACvB,0BAA0B,CAAC;AAU/B,oBAAY,cAAc,GAAG,IAAI,CAC/B,QAAQ,CAAC,cAAc,CAAC,EACtB,UAAU,GACV,cAAc,GACd,kBAAkB,GAClB,oBAAoB,GACpB,QAAQ,GACR,SAAS,GACT,SAAS,GACT,aAAa,GACb,YAAY,CACf,GAAG;IACF,WAAW,EAAE,WAAW,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC;IACxD,UAAU,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;IACzC,YAAY,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;IAC3C,WAAW,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;CACvD,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS;IAC5B,OAAO,CAAC,IAAI,CAAiB;IAC7B,OAAO,CAAC,iBAAiB,CAAmB;IAC5C,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,MAAM,CAAiB;IAE/B,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,cAAc,CAAwB;IAC9C,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,YAAY,CAAU;IAC9B,OAAO,CAAC,mBAAmB,CAAU;IAErC,OAAO,CAAC,QAAQ,CAAC,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,CAAS;IAE1B,OAAO,CAAC,UAAU,CAA+B;IAEjD;;;OAGG;gBACS,IAAI,EAAE,cAAc;IAkChC,IAAI,KAAK,wBAER;IAED,IAAI,aAAa,IAAI,YAAY,EAAE,GAAG,IAAI,CAEzC;IAED,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI;IAWtC,QAAQ,IAAI,IAAI;IAWhB,SAAS,IAAI,IAAI;IAWjB;;OAEG;IACH,MAAM,CACJ,QAAQ,EAAE,QAAQ,EAClB,EAAC,MAAM,EAAE,WAAW,EAAC,GAAE;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,OAAO,CAAA;KAAM,GACnE,MAAM;IA8CT,4DAA4D;IAC5D,cAAc,CAAC,EACb,QAAQ,EACR,OAAO,EACP,OAAO,EACP,MAAM,EACN,WAAW,EACX,kBAAkB,EACnB,EAAE;QACD,QAAQ,EAAE,QAAQ,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;QAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,GAAG,SAAS,EAAE;IAef,iDAAiD;IACjD,SAAS,CAAC,KAAK,EAAE,SAAS;IAI1B,4CAA4C;IAC5C,WAAW,CAAC,KAAK,EAAE,SAAS;IAI5B,kEAAkE;IAClE,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAMtD,uCAAuC;IACvC,cAAc,CAAC,KAAK,EAAE,SAAS;;;;;IAQ/B,OAAO,CAAC,gBAAgB;IAoCxB,cAAc,IAAI,IAAI;IAwBtB,YAAY;IAqBZ;;OAEG;IAEH,OAAO,CAAC,YAAY;IAmCpB,OAAO,CAAC,QAAQ;IA8BhB,mBAAmB,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,GAAG,IAAI;CAa7D"}