@loaders.gl/tiles 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/tileset/tileset-cache.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Stores tiles with content loaded.
+ *
+ * @private
+ */
+export declare class TilesetCache {
+    private _list;
+    private _sentinel;
+    private _trimTiles;
+    constructor();
+    reset(): void;
+    touch(tile: any): void;
+    add(tileset: any, tile: any, addCallback: any): void;
+    unloadTile(tileset: any, tile: any, unloadCallback?: any): void;
+    unloadTiles(tileset: any, unloadCallback: any): void;
+    trim(): void;
+}
+//# sourceMappingURL=tileset-cache.d.ts.map

package/dist/tileset/tileset-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tileset-cache.d.ts","sourceRoot":"","sources":["../../src/tileset/tileset-cache.ts"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,UAAU,CAAU;;IAU5B,KAAK;IAOL,KAAK,CAAC,IAAI,KAAA;IAOV,GAAG,CAAC,OAAO,KAAA,EAAE,IAAI,KAAA,EAAE,WAAW,KAAA;IAU9B,UAAU,CAAC,OAAO,KAAA,EAAE,IAAI,KAAA,EAAE,cAAc,CAAC,KAAA;IAazC,WAAW,CAAC,OAAO,KAAA,EAAE,cAAc,KAAA;IA0BnC,IAAI;CAGL"}

package/dist/tileset/tileset-cache.js

@@ -1,79 +1,78 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import DoublyLinkedList from '../utils/doubly-linked-list';
-
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TilesetCache = void 0;
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+const doubly_linked_list_1 = require("../utils/doubly-linked-list");
 function defined(x) {
-  return x !== undefined && x !== null;
+    return x !== undefined && x !== null;
 }
-
-export default class TilesetCache {
-  constructor() {
-    _defineProperty(this, "_list", void 0);
-
-    _defineProperty(this, "_sentinel", void 0);
-
-    _defineProperty(this, "_trimTiles", void 0);
-
-    this._list = new DoublyLinkedList();
-    this._sentinel = this._list.add('sentinel');
-    this._trimTiles = false;
-  }
-
-  reset() {
-    this._list.splice(this._list.tail, this._sentinel);
-  }
-
-  touch(tile) {
-    const node = tile._cacheNode;
-
-    if (defined(node)) {
-      this._list.splice(this._sentinel, node);
+/**
+ * Stores tiles with content loaded.
+ *
+ * @private
+ */
+class TilesetCache {
+    constructor() {
+        // [head, sentinel) -> tiles that weren't selected this frame and may be removed from the cache
+        // (sentinel, tail] -> tiles that were selected this frame
+        this._list = new doubly_linked_list_1.DoublyLinkedList();
+        this._sentinel = this._list.add('sentinel');
+        this._trimTiles = false;
     }
-  }
-
-  add(tileset, tile, addCallback) {
-    if (!defined(tile._cacheNode)) {
-      tile._cacheNode = this._list.add(tile);
-
-      if (addCallback) {
-        addCallback(tileset, tile);
-      }
+    reset() {
+        // Move sentinel node to the tail so, at the start of the frame, all tiles
+        // may be potentially replaced.  Tiles are moved to the right of the sentinel
+        // when they are selected so they will not be replaced.
+        this._list.splice(this._list.tail, this._sentinel);
     }
-  }
-
-  unloadTile(tileset, tile, unloadCallback) {
-    const node = tile._cacheNode;
-
-    if (!defined(node)) {
-      return;
+    touch(tile) {
+        const node = tile._cacheNode;
+        if (defined(node)) {
+            this._list.splice(this._sentinel, node);
+        }
     }
-
-    this._list.remove(node);
-
-    tile._cacheNode = undefined;
-
-    if (unloadCallback) {
-      unloadCallback(tileset, tile);
+    add(tileset, tile, addCallback) {
+        if (!defined(tile._cacheNode)) {
+            tile._cacheNode = this._list.add(tile);
+            if (addCallback) {
+                addCallback(tileset, tile);
+            }
+        }
     }
-  }
-
-  unloadTiles(tileset, unloadCallback) {
-    const trimTiles = this._trimTiles;
-    this._trimTiles = false;
-    const list = this._list;
-    const maximumMemoryUsageInBytes = tileset.maximumMemoryUsage * 1024 * 1024;
-    const sentinel = this._sentinel;
-    let node = list.head;
-
-    while (node !== sentinel && (tileset.gpuMemoryUsageInBytes > maximumMemoryUsageInBytes || trimTiles)) {
-      const tile = node.item;
-      node = node.next;
-      this.unloadTile(tileset, tile, unloadCallback);
+    unloadTile(tileset, tile, unloadCallback) {
+        const node = tile._cacheNode;
+        if (!defined(node)) {
+            return;
+        }
+        this._list.remove(node);
+        tile._cacheNode = undefined;
+        if (unloadCallback) {
+            unloadCallback(tileset, tile);
+        }
+    }
+    unloadTiles(tileset, unloadCallback) {
+        const trimTiles = this._trimTiles;
+        this._trimTiles = false;
+        const list = this._list;
+        const maximumMemoryUsageInBytes = tileset.maximumMemoryUsage * 1024 * 1024;
+        // Traverse the list only to the sentinel since tiles/nodes to the
+        // right of the sentinel were used this frame.
+        // The sub-list to the left of the sentinel is ordered from LRU to MRU.
+        const sentinel = this._sentinel;
+        let node = list.head;
+        while (node !== sentinel &&
+            (tileset.gpuMemoryUsageInBytes > maximumMemoryUsageInBytes || trimTiles)) {
+            // @ts-expect-error
+            const tile = node.item;
+            // @ts-expect-error
+            node = node.next;
+            this.unloadTile(tileset, tile, unloadCallback);
+        }
+    }
+    trim() {
+        this._trimTiles = true;
     }
-  }
-
-  trim() {
-    this._trimTiles = true;
-  }
-
 }
-//# sourceMappingURL=tileset-cache.js.map
+exports.TilesetCache = TilesetCache;

package/dist/tileset/tileset-traverser.d.ts

@@ -0,0 +1,46 @@
+import { ManagedArray } from '../utils/managed-array';
+import { FrameState } from './helpers/frame-state';
+export type TilesetTraverserProps = {
+    loadSiblings?: boolean;
+    skipLevelOfDetail?: boolean;
+    maximumScreenSpaceError?: number;
+    onTraversalEnd?: (frameState: any) => any;
+    viewportTraversersMap?: {
+        [key: string]: any;
+    };
+    basePath?: string;
+    updateTransforms?: boolean;
+};
+export declare const DEFAULT_PROPS: Required<TilesetTraverserProps>;
+export declare class TilesetTraverser {
+    options: Required<TilesetTraverserProps>;
+    root: any;
+    requestedTiles: object;
+    selectedTiles: object;
+    emptyTiles: object;
+    protected lastUpdate: number;
+    protected readonly updateDebounceTime = 1000;
+    protected _traversalStack: ManagedArray;
+    protected _emptyTraversalStack: ManagedArray;
+    protected _frameNumber: number | null;
+    protected traversalFinished(frameState: FrameState): boolean;
+    constructor(options: TilesetTraverserProps);
+    traverse(root: any, frameState: any, options: any): void;
+    reset(): void;
+    executeTraversal(root: any, frameState: FrameState): void;
+    updateChildTiles(tile: any, frameState: any): boolean;
+    updateAndPushChildren(tile: any, frameState: any, stack: any, depth: any): boolean;
+    updateTile(tile: any, frameState: any): void;
+    selectTile(tile: any, frameState: any): void;
+    loadTile(tile: any, frameState: any): void;
+    touchTile(tile: any, frameState: any): void;
+    canTraverse(tile: any, frameState: any, useParentMetric?: boolean, ignoreVisibility?: boolean): boolean;
+    shouldLoadTile(tile: any): any;
+    shouldSelectTile(tile: any): any;
+    shouldRefine(tile: any, frameState: any, useParentMetric: any): boolean;
+    updateTileVisibility(tile: any, frameState: any): void;
+    compareDistanceToCamera(b: any, a: any): number;
+    anyChildrenVisible(tile: any, frameState: any): boolean;
+    executeEmptyTraversal(root: any, frameState: any): boolean;
+}
+//# sourceMappingURL=tileset-traverser.d.ts.map

package/dist/tileset/tileset-traverser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tileset-traverser.d.ts","sourceRoot":"","sources":["../../src/tileset/tileset-traverser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,wBAAwB,CAAC;AAEpD,OAAO,EAAC,UAAU,EAAC,MAAM,uBAAuB,CAAC;AAEjD,MAAM,MAAM,qBAAqB,GAAG;IAClC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,cAAc,CAAC,EAAE,CAAC,UAAU,KAAA,KAAK,GAAG,CAAC;IACrC,qBAAqB,CAAC,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAAC;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAYF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,qBAAqB,CAQzD,CAAC;AAEF,qBAAa,gBAAgB;IAC3B,OAAO,EAAE,QAAQ,CAAC,qBAAqB,CAAC,CAAC;IAEzC,IAAI,EAAE,GAAG,CAAC;IACV,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IAEnB,SAAS,CAAC,UAAU,EAAE,MAAM,CAAwB;IACpD,SAAS,CAAC,QAAQ,CAAC,kBAAkB,QAAQ;IAC7C,SAAS,CAAC,eAAe,EAAE,YAAY,CAAC;IACxC,SAAS,CAAC,oBAAoB,EAAE,YAAY,CAAC;IAC7C,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAEtC,SAAS,CAAC,iBAAiB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO;gBAKhD,OAAO,EAAE,qBAAqB;IAuB1C,QAAQ,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA,EAAE,OAAO,KAAA;IAclC,KAAK;IAgBL,gBAAgB,CAAC,IAAI,KAAA,EAAE,UAAU,EAAE,UAAU;IAmE7C,gBAAgB,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IASjC,qBAAqB,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA,EAAE,KAAK,KAAA,EAAE,KAAK,KAAA;IAuDpD,UAAU,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IAK3B,UAAU,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IAS3B,QAAQ,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IASzB,SAAS,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IAQ1B,WAAW,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA,EAAE,eAAe,UAAQ,EAAE,gBAAgB,UAAQ;IAmB/E,cAAc,CAAC,IAAI,KAAA;IAMnB,gBAAgB,CAAC,IAAI,KAAA;IAOrB,YAAY,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA,EAAE,eAAe,KAAA;IAS9C,oBAAoB,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IAiBrC,uBAAuB,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;IAI5B,kBAAkB,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IAWnC,qBAAqB,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;CAqCvC"}

package/dist/tileset/tileset-traverser.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TilesetTraverser = exports.DEFAULT_PROPS = void 0;
+const managed_array_1 = require("../utils/managed-array");
+const constants_1 = require("../constants");
+// export type Props = {
+//   loadSiblings: boolean;
+//   skipLevelOfDetail: boolean;
+//   updateTransforms: boolean;
+//   maximumScreenSpaceError: number;
+//   onTraversalEnd: (frameState) => any;
+//   viewportTraversersMap: {[key: string]: any};
+//   basePath: string;
+// };
+exports.DEFAULT_PROPS = {
+    loadSiblings: false,
+    skipLevelOfDetail: false,
+    maximumScreenSpaceError: 2,
+    updateTransforms: true,
+    onTraversalEnd: () => { },
+    viewportTraversersMap: {},
+    basePath: ''
+};
+class TilesetTraverser {
+    traversalFinished(frameState) {
+        return true;
+    }
+    // TODO nested props
+    constructor(options) {
+        this.lastUpdate = new Date().getTime();
+        this.updateDebounceTime = 1000;
+        this.options = { ...exports.DEFAULT_PROPS, ...options };
+        // TRAVERSAL
+        // temporary storage to hold the traversed tiles during a traversal
+        this._traversalStack = new managed_array_1.ManagedArray();
+        this._emptyTraversalStack = new managed_array_1.ManagedArray();
+        // set in every traverse cycle
+        this._frameNumber = null;
+        // fulfill in traverse call
+        this.root = null;
+        // RESULT
+        // tiles should be rendered
+        this.selectedTiles = {};
+        // tiles should be loaded from server
+        this.requestedTiles = {};
+        // tiles does not have render content
+        this.emptyTiles = {};
+    }
+    // tiles should be visible
+    traverse(root, frameState, options) {
+        this.root = root; // for root screen space error
+        this.options = { ...this.options, ...options };
+        // reset result
+        this.reset();
+        // update tile (visibility and expiration)
+        this.updateTile(root, frameState);
+        this._frameNumber = frameState.frameNumber;
+        this.executeTraversal(root, frameState);
+    }
+    reset() {
+        this.requestedTiles = {};
+        this.selectedTiles = {};
+        this.emptyTiles = {};
+        this._traversalStack.reset();
+        this._emptyTraversalStack.reset();
+    }
+    // execute traverse
+    // Depth-first traversal that traverses all visible tiles and marks tiles for selection.
+    // If skipLevelOfDetail is off then a tile does not refine until all children are loaded.
+    // This is the traditional replacement refinement approach and is called the base traversal.
+    // Tiles that have a greater screen space error than the base screen space error are part of the base traversal,
+    // all other tiles are part of the skip traversal. The skip traversal allows for skipping levels of the tree
+    // and rendering children and parent tiles simultaneously.
+    /* eslint-disable-next-line complexity, max-statements */
+    executeTraversal(root, frameState) {
+        // stack to store traversed tiles, only visible tiles should be added to stack
+        // visible: visible in the current view frustum
+        const stack = this._traversalStack;
+        root._selectionDepth = 1;
+        stack.push(root);
+        while (stack.length > 0) {
+            // 1. pop tile
+            const tile = stack.pop();
+            // 2. check if tile needs to be refine, needs refine if a tile's LoD is not sufficient and tile has available children (available content)
+            let shouldRefine = false;
+            if (this.canTraverse(tile, frameState)) {
+                this.updateChildTiles(tile, frameState);
+                shouldRefine = this.updateAndPushChildren(tile, frameState, stack, tile.hasRenderContent ? tile._selectionDepth + 1 : tile._selectionDepth);
+            }
+            // 3. decide if should render (select) this tile
+            //   - tile does not have render content
+            //   - tile has render content and tile is `add` type (pointcloud)
+            //   - tile has render content and tile is `replace` type (photogrammetry) and can't refine any further
+            const parent = tile.parent;
+            const parentRefines = Boolean(!parent || parent._shouldRefine);
+            const stoppedRefining = !shouldRefine;
+            if (!tile.hasRenderContent) {
+                this.emptyTiles[tile.id] = tile;
+                this.loadTile(tile, frameState);
+                if (stoppedRefining) {
+                    this.selectTile(tile, frameState);
+                }
+                // additive tiles
+            }
+            else if (tile.refine === constants_1.TILE_REFINEMENT.ADD) {
+                // Additive tiles are always loaded and selected
+                this.loadTile(tile, frameState);
+                this.selectTile(tile, frameState);
+                // replace tiles
+            }
+            else if (tile.refine === constants_1.TILE_REFINEMENT.REPLACE) {
+                // Always load tiles in the base traversal
+                // Select tiles that can't refine further
+                this.loadTile(tile, frameState);
+                if (stoppedRefining) {
+                    this.selectTile(tile, frameState);
+                }
+            }
+            // 3. update cache, most recent touched tiles have higher priority to be fetched from server
+            this.touchTile(tile, frameState);
+            // 4. update tile refine prop and parent refinement status to trickle down to the descendants
+            tile._shouldRefine = shouldRefine && parentRefines;
+        }
+        const newTime = new Date().getTime();
+        if (this.traversalFinished(frameState) || newTime - this.lastUpdate > this.updateDebounceTime) {
+            this.lastUpdate = newTime;
+            this.options.onTraversalEnd(frameState);
+        }
+    }
+    updateChildTiles(tile, frameState) {
+        const children = tile.children;
+        for (const child of children) {
+            this.updateTile(child, frameState);
+        }
+        return true;
+    }
+    /* eslint-disable complexity, max-statements */
+    updateAndPushChildren(tile, frameState, stack, depth) {
+        const { loadSiblings, skipLevelOfDetail } = this.options;
+        const children = tile.children;
+        // sort children tiles
+        children.sort(this.compareDistanceToCamera.bind(this));
+        // For traditional replacement refinement only refine if all children are loaded.
+        // Empty tiles are exempt since it looks better if children stream in as they are loaded to fill the empty space.
+        const checkRefines = tile.refine === constants_1.TILE_REFINEMENT.REPLACE && tile.hasRenderContent && !skipLevelOfDetail;
+        let hasVisibleChild = false;
+        let refines = true;
+        for (const child of children) {
+            child._selectionDepth = depth;
+            if (child.isVisibleAndInRequestVolume) {
+                if (stack.find(child)) {
+                    stack.delete(child);
+                }
+                stack.push(child);
+                hasVisibleChild = true;
+            }
+            else if (checkRefines || loadSiblings) {
+                // Keep non-visible children loaded since they are still needed before the parent can refine.
+                // Or loadSiblings is true so always load tiles regardless of visibility.
+                this.loadTile(child, frameState);
+                this.touchTile(child, frameState);
+            }
+            if (checkRefines) {
+                let childRefines;
+                if (!child._inRequestVolume) {
+                    childRefines = false;
+                }
+                else if (!child.hasRenderContent) {
+                    childRefines = this.executeEmptyTraversal(child, frameState);
+                }
+                else {
+                    childRefines = child.contentAvailable;
+                }
+                refines = refines && childRefines;
+                if (!refines) {
+                    return false;
+                }
+            }
+        }
+        if (!hasVisibleChild) {
+            refines = false;
+        }
+        return refines;
+    }
+    /* eslint-enable complexity, max-statements */
+    updateTile(tile, frameState) {
+        this.updateTileVisibility(tile, frameState);
+    }
+    // tile to render in the browser
+    selectTile(tile, frameState) {
+        if (this.shouldSelectTile(tile)) {
+            // The tile can be selected right away and does not require traverseAndSelect
+            tile._selectedFrame = frameState.frameNumber;
+            this.selectedTiles[tile.id] = tile;
+        }
+    }
+    // tile to load from server
+    loadTile(tile, frameState) {
+        if (this.shouldLoadTile(tile)) {
+            tile._requestedFrame = frameState.frameNumber;
+            tile._priority = tile._getPriority();
+            this.requestedTiles[tile.id] = tile;
+        }
+    }
+    // cache tile
+    touchTile(tile, frameState) {
+        tile.tileset._cache.touch(tile);
+        tile._touchedFrame = frameState.frameNumber;
+    }
+    // tile should be visible
+    // tile should have children
+    // tile LoD (level of detail) is not sufficient under current viewport
+    canTraverse(tile, frameState, useParentMetric = false, ignoreVisibility = false) {
+        if (!tile.hasChildren) {
+            return false;
+        }
+        // cesium specific
+        if (tile.hasTilesetContent) {
+            // Traverse external this to visit its root tile
+            // Don't traverse if the subtree is expired because it will be destroyed
+            return !tile.contentExpired;
+        }
+        if (!ignoreVisibility && !tile.isVisibleAndInRequestVolume) {
+            return false;
+        }
+        return this.shouldRefine(tile, frameState, useParentMetric);
+    }
+    shouldLoadTile(tile) {
+        // if request tile is in current frame
+        // and has unexpired render content
+        return tile.hasUnloadedContent || tile.contentExpired;
+    }
+    shouldSelectTile(tile) {
+        // if select tile is in current frame
+        // and content available
+        return tile.contentAvailable && !this.options.skipLevelOfDetail;
+    }
+    // Decide if tile LoD (level of detail) is not sufficient under current viewport
+    shouldRefine(tile, frameState, useParentMetric) {
+        let screenSpaceError = tile._screenSpaceError;
+        if (useParentMetric) {
+            screenSpaceError = tile.getScreenSpaceError(frameState, true);
+        }
+        return screenSpaceError > this.options.maximumScreenSpaceError;
+    }
+    updateTileVisibility(tile, frameState) {
+        const viewportIds = [];
+        if (this.options.viewportTraversersMap) {
+            for (const key in this.options.viewportTraversersMap) {
+                const value = this.options.viewportTraversersMap[key];
+                if (value === frameState.viewport.id) {
+                    viewportIds.push(key);
+                }
+            }
+        }
+        else {
+            viewportIds.push(frameState.viewport.id);
+        }
+        tile.updateVisibility(frameState, viewportIds);
+    }
+    // UTILITIES
+    compareDistanceToCamera(b, a) {
+        return b._distanceToCamera - a._distanceToCamera;
+    }
+    anyChildrenVisible(tile, frameState) {
+        let anyVisible = false;
+        for (const child of tile.children) {
+            child.updateVisibility(frameState);
+            anyVisible = anyVisible || child.isVisibleAndInRequestVolume;
+        }
+        return anyVisible;
+    }
+    // Depth-first traversal that checks if all nearest descendants with content are loaded.
+    // Ignores visibility.
+    executeEmptyTraversal(root, frameState) {
+        let allDescendantsLoaded = true;
+        const stack = this._emptyTraversalStack;
+        stack.push(root);
+        while (stack.length > 0 && allDescendantsLoaded) {
+            const tile = stack.pop();
+            this.updateTile(tile, frameState);
+            if (!tile.isVisibleAndInRequestVolume) {
+                // Load tiles that aren't visible since they are still needed for the parent to refine
+                this.loadTile(tile, frameState);
+            }
+            this.touchTile(tile, frameState);
+            // Only traverse if the tile is empty - traversal stop at descendants with content
+            const traverse = !tile.hasRenderContent && this.canTraverse(tile, frameState, false, true);
+            if (traverse) {
+                const children = tile.children;
+                for (const child of children) {
+                    // eslint-disable-next-line max-depth
+                    if (stack.find(child)) {
+                        stack.delete(child);
+                    }
+                    stack.push(child);
+                }
+            }
+            else if (!tile.contentAvailable) {
+                allDescendantsLoaded = false;
+            }
+        }
+        return allDescendantsLoaded;
+    }
+}
+exports.TilesetTraverser = TilesetTraverser;
+// TODO
+// enable expiration
+// enable optimization hint

package/dist/types.d.ts

@@ -0,0 +1,34 @@
+import { Vector3 } from '@math.gl/core';
+export type BoundingRectangle = {
+    width: number;
+    height: number;
+};
+/** Deck.gl Viewport instance type.
+ * We can't import it from Deck.gl to avoid circular reference */
+export type Viewport = {
+    id: string;
+    cameraPosition: number[] | Vector3;
+    height: number;
+    width: number;
+    zoom: number;
+    distanceScales: {
+        unitsPerMeter: number[];
+        metersPerUnit: number[];
+    };
+    center: number[] | Vector3;
+    unprojectPosition: (position: number[] | Vector3) => [number, number, number];
+    project: (coorinates: number[] | Vector3) => number[];
+};
+/**
+ * Contain extra fields from WebMercatorViewport and FirstPersonViewport
+ */
+export type GeospatialViewport = Viewport & {
+    /** @todo This field is not represented in Deck.gl viewports. Can be removed in the next version */
+    cameraDirection: [number, number, number];
+    /** @todo This field is not represented in Deck.gl viewports. Can be removed in the next version */
+    cameraUp: [number, number, number];
+    longitude: number;
+    latitude: number;
+    bearing: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AAEtC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;iEACiE;AACjE,MAAM,MAAM,QAAQ,GAAG;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE;QACd,aAAa,EAAE,MAAM,EAAE,CAAC;QACxB,aAAa,EAAE,MAAM,EAAE,CAAC;KACzB,CAAC;IACF,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAC3B,iBAAiB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9E,OAAO,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,OAAO,KAAK,MAAM,EAAE,CAAC;CACvD,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG;IAC1C,mGAAmG;IACnG,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,mGAAmG;IACnG,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC"}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/doubly-linked-list-node.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Doubly linked list node
+ * @private
+ */
+export declare class DoublyLinkedListNode {
+    item: any;
+    previous: any;
+    next: any;
+    constructor(item: any, previous: any, next: any);
+}
+//# sourceMappingURL=doubly-linked-list-node.d.ts.map

package/dist/utils/doubly-linked-list-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doubly-linked-list-node.d.ts","sourceRoot":"","sources":["../../src/utils/doubly-linked-list-node.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,qBAAa,oBAAoB;IAC/B,IAAI,MAAC;IACL,QAAQ,MAAC;IACT,IAAI,MAAC;gBAEO,IAAI,KAAA,EAAE,QAAQ,KAAA,EAAE,IAAI,KAAA;CAKjC"}

package/dist/utils/doubly-linked-list-node.js

@@ -1,9 +1,18 @@
-export default class DoublyLinkedListNode {
-  constructor(item, previous, next) {
-    this.item = item;
-    this.previous = previous;
-    this.next = next;
-  }
-
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoublyLinkedListNode = void 0;
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+/**
+ * Doubly linked list node
+ * @private
+ */
+class DoublyLinkedListNode {
+    constructor(item, previous, next) {
+        this.item = item;
+        this.previous = previous;
+        this.next = next;
+    }
 }
-//# sourceMappingURL=doubly-linked-list-node.js.map
+exports.DoublyLinkedListNode = DoublyLinkedListNode;

package/dist/utils/doubly-linked-list.d.ts

@@ -0,0 +1,30 @@
+import { DoublyLinkedListNode } from './doubly-linked-list-node';
+/**
+ * Doubly linked list
+ * @private
+ */
+export declare class DoublyLinkedList {
+    head: DoublyLinkedListNode | null;
+    tail: DoublyLinkedListNode | null;
+    _length: number;
+    get length(): number;
+    /**
+     * Adds the item to the end of the list
+     * @param {*} [item]
+     * @return {DoublyLinkedListNode}
+     */
+    add(item: any): DoublyLinkedListNode;
+    /**
+     * Removes the given node from the list
+     * @param {DoublyLinkedListNode} node
+     */
+    remove(node: any): void;
+    /**
+     * Moves nextNode after node
+     * @param {DoublyLinkedListNode} node
+     * @param {DoublyLinkedListNode} nextNode
+     */
+    splice(node: any, nextNode: any): void;
+    _insert(node: any, nextNode: any): void;
+}
+//# sourceMappingURL=doubly-linked-list.d.ts.map

package/dist/utils/doubly-linked-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doubly-linked-list.d.ts","sourceRoot":"","sources":["../../src/utils/doubly-linked-list.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,oBAAoB,EAAC,MAAM,2BAA2B,CAAC;AAE/D;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAAQ;IACzC,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAAQ;IACzC,OAAO,SAAK;IAEZ,IAAI,MAAM,WAET;IAED;;;;OAIG;IACH,GAAG,CAAC,IAAI,KAAA;IAgBR;;;OAGG;IACH,MAAM,CAAC,IAAI,KAAA;IA4BX;;;;OAIG;IACH,MAAM,CAAC,IAAI,KAAA,EAAE,QAAQ,KAAA;IAUrB,OAAO,CAAC,IAAI,KAAA,EAAE,QAAQ,KAAA;CAgBvB"}