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

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

@@ -1,81 +1,97 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import DoublyLinkedListNode from '../utils/doubly-linked-list-node';
-export default class DoublyLinkedList {
-  constructor() {
-    _defineProperty(this, "head", null);
-
-    _defineProperty(this, "tail", null);
-
-    _defineProperty(this, "_length", 0);
-  }
-
-  get length() {
-    return this._length;
-  }
-
-  add(item) {
-    const node = new DoublyLinkedListNode(item, this.tail, null);
-
-    if (this.tail) {
-      this.tail.next = node;
-      this.tail = node;
-    } else {
-      this.head = node;
-      this.tail = node;
+"use strict";
+// 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
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoublyLinkedList = void 0;
+const doubly_linked_list_node_1 = require("./doubly-linked-list-node");
+/**
+ * Doubly linked list
+ * @private
+ */
+class DoublyLinkedList {
+    constructor() {
+        this.head = null;
+        this.tail = null;
+        this._length = 0;
     }
-
-    ++this._length;
-    return node;
-  }
-
-  remove(node) {
-    if (!node) {
-      return;
+    get length() {
+        return this._length;
     }
-
-    if (node.previous && node.next) {
-      node.previous.next = node.next;
-      node.next.previous = node.previous;
-    } else if (node.previous) {
-      node.previous.next = null;
-      this.tail = node.previous;
-    } else if (node.next) {
-      node.next.previous = null;
-      this.head = node.next;
-    } else {
-      this.head = null;
-      this.tail = null;
+    /**
+     * Adds the item to the end of the list
+     * @param {*} [item]
+     * @return {DoublyLinkedListNode}
+     */
+    add(item) {
+        const node = new doubly_linked_list_node_1.DoublyLinkedListNode(item, this.tail, null);
+        if (this.tail) {
+            this.tail.next = node;
+            this.tail = node;
+        }
+        else {
+            this.head = node;
+            this.tail = node;
+        }
+        ++this._length;
+        return node;
     }
-
-    node.next = null;
-    node.previous = null;
-    --this._length;
-  }
-
-  splice(node, nextNode) {
-    if (node === nextNode) {
-      return;
+    /**
+     * Removes the given node from the list
+     * @param {DoublyLinkedListNode} node
+     */
+    remove(node) {
+        if (!node) {
+            return;
+        }
+        if (node.previous && node.next) {
+            node.previous.next = node.next;
+            node.next.previous = node.previous;
+        }
+        else if (node.previous) {
+            // Remove last node
+            node.previous.next = null;
+            this.tail = node.previous;
+        }
+        else if (node.next) {
+            // Remove first node
+            node.next.previous = null;
+            this.head = node.next;
+        }
+        else {
+            // Remove last node in the linked list
+            this.head = null;
+            this.tail = null;
+        }
+        node.next = null;
+        node.previous = null;
+        --this._length;
     }
-
-    this.remove(nextNode);
-
-    this._insert(node, nextNode);
-  }
-
-  _insert(node, nextNode) {
-    const oldNodeNext = node.next;
-    node.next = nextNode;
-
-    if (this.tail === node) {
-      this.tail = nextNode;
-    } else {
-      oldNodeNext.previous = nextNode;
+    /**
+     * Moves nextNode after node
+     * @param {DoublyLinkedListNode} node
+     * @param {DoublyLinkedListNode} nextNode
+     */
+    splice(node, nextNode) {
+        if (node === nextNode) {
+            return;
+        }
+        // Remove nextNode, then insert after node
+        this.remove(nextNode);
+        this._insert(node, nextNode);
+    }
+    _insert(node, nextNode) {
+        const oldNodeNext = node.next;
+        node.next = nextNode;
+        // nextNode is the new tail
+        if (this.tail === node) {
+            this.tail = nextNode;
+        }
+        else {
+            oldNodeNext.previous = nextNode;
+        }
+        nextNode.next = oldNodeNext;
+        nextNode.previous = node;
+        ++this._length;
     }
-
-    nextNode.next = oldNodeNext;
-    nextNode.previous = node;
-    ++this._length;
-  }
-
 }
-//# sourceMappingURL=doubly-linked-list.js.map
+exports.DoublyLinkedList = DoublyLinkedList;

package/dist/utils/managed-array.d.ts

@@ -7,7 +7,7 @@
  *
  * @param {Number} [length=0] The initial length of the array.
  */
-export default class ManagedArray {
+export declare class ManagedArray {
     _map: Map<any, any>;
     _array: any[];
     _length: number;

package/dist/utils/managed-array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"managed-array.d.ts","sourceRoot":"","sources":["../../src/utils/managed-array.ts"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,IAAI,gBAAa;IACjB,MAAM,EAAE,GAAG,EAAE,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;gBAEJ,MAAM,SAAI;IAKtB;;;;;;OAMG;IACH,IAAI,MAAM,WAET;IAED,IAAI,MAAM,CAAC,MAAM,QAAA,EAKhB;IAED;;;;;;OAMG;IACH,IAAI,MAAM,UAET;IAED;;;;OAIG;IACH,GAAG,CAAC,KAAK,KAAA;IAKT;;;;;OAKG;IACH,GAAG,CAAC,KAAK,KAAA,EAAE,OAAO,KAAA;IAelB,MAAM,CAAC,OAAO,KAAA;IASd;;;;OAIG;IACH,IAAI;IAIJ;;;;OAIG;IACH,IAAI,CAAC,OAAO,KAAA;IAQZ;;;;OAIG;IACH,GAAG;IAMH;;;;OAIG;IACH,OAAO,CAAC,MAAM,KAAA;IAQd;;;;OAIG;IACH,MAAM,CAAC,MAAM,KAAA;IAMb;;;;OAIG;IACH,IAAI,CAAC,MAAM,KAAA;IAOX,KAAK;IAML,IAAI,CAAC,MAAM,KAAA;CAGZ"}
+{"version":3,"file":"managed-array.d.ts","sourceRoot":"","sources":["../../src/utils/managed-array.ts"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,qBAAa,YAAY;IACvB,IAAI,gBAAa;IACjB,MAAM,EAAE,GAAG,EAAE,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;gBAEJ,MAAM,SAAI;IAKtB;;;;;;OAMG;IACH,IAAI,MAAM,WAET;IAED,IAAI,MAAM,CAAC,MAAM,QAAA,EAKhB;IAED;;;;;;OAMG;IACH,IAAI,MAAM,UAET;IAED;;;;OAIG;IACH,GAAG,CAAC,KAAK,KAAA;IAKT;;;;;OAKG;IACH,GAAG,CAAC,KAAK,KAAA,EAAE,OAAO,KAAA;IAelB,MAAM,CAAC,OAAO,KAAA;IASd;;;;OAIG;IACH,IAAI;IAIJ;;;;OAIG;IACH,IAAI,CAAC,OAAO,KAAA;IAQZ;;;;OAIG;IACH,GAAG;IAMH;;;;OAIG;IACH,OAAO,CAAC,MAAM,KAAA;IAQd;;;;OAIG;IACH,MAAM,CAAC,MAAM,KAAA;IAMb;;;;OAIG;IACH,IAAI,CAAC,MAAM,KAAA;IAOX,KAAK;IAML,IAAI,CAAC,MAAM,KAAA;CAGZ"}

package/dist/utils/managed-array.js

@@ -1,117 +1,152 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { assert } from '@loaders.gl/loader-utils';
-export default class ManagedArray {
-  constructor(length = 0) {
-    _defineProperty(this, "_map", new Map());
-
-    _defineProperty(this, "_array", void 0);
-
-    _defineProperty(this, "_length", void 0);
-
-    this._array = new Array(length);
-    this._length = length;
-  }
-
-  get length() {
-    return this._length;
-  }
-
-  set length(length) {
-    this._length = length;
-
-    if (length > this._array.length) {
-      this._array.length = length;
+"use strict";
+// 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
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManagedArray = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+/**
+ * A wrapper around arrays so that the internal length of the array can be manually managed.
+ *
+ * @alias ManagedArray
+ * @constructor
+ * @private
+ *
+ * @param {Number} [length=0] The initial length of the array.
+ */
+class ManagedArray {
+    constructor(length = 0) {
+        this._map = new Map();
+        this._array = new Array(length);
+        this._length = length;
     }
-  }
-
-  get values() {
-    return this._array;
-  }
-
-  get(index) {
-    assert(index < this._array.length);
-    return this._array[index];
-  }
-
-  set(index, element) {
-    assert(index >= 0);
-
-    if (index >= this.length) {
-      this.length = index + 1;
+    /**
+     * Gets or sets the length of the array.
+     * If the set length is greater than the length of the internal array, the internal array is resized.
+     *
+     * @memberof ManagedArray.prototype
+     * @type Number
+     */
+    get length() {
+        return this._length;
     }
-
-    if (this._map.has(this._array[index])) {
-      this._map.delete(this._array[index]);
+    set length(length) {
+        this._length = length;
+        if (length > this._array.length) {
+            this._array.length = length;
+        }
     }
-
-    this._array[index] = element;
-
-    this._map.set(element, index);
-  }
-
-  delete(element) {
-    const index = this._map.get(element);
-
-    if (index >= 0) {
-      this._array.splice(index, 1);
-
-      this._map.delete(element);
-
-      this.length--;
+    /**
+     * Gets the internal array.
+     *
+     * @memberof ManagedArray.prototype
+     * @type Array
+     * @readonly
+     */
+    get values() {
+        return this._array;
     }
-  }
-
-  peek() {
-    return this._array[this._length - 1];
-  }
-
-  push(element) {
-    if (!this._map.has(element)) {
-      const index = this.length++;
-      this._array[index] = element;
-
-      this._map.set(element, index);
+    /**
+     * Gets the element at an index.
+     *
+     * @param {Number} index The index to get.
+     */
+    get(index) {
+        (0, loader_utils_1.assert)(index < this._array.length);
+        return this._array[index];
     }
-  }
-
-  pop() {
-    const element = this._array[--this.length];
-
-    this._map.delete(element);
-
-    return element;
-  }
-
-  reserve(length) {
-    assert(length >= 0);
-
-    if (length > this._array.length) {
-      this._array.length = length;
+    /**
+     * Sets the element at an index. Resizes the array if index is greater than the length of the array.
+     *
+     * @param {Number} index The index to set.
+     * @param {*} element The element to set at index.
+     */
+    set(index, element) {
+        (0, loader_utils_1.assert)(index >= 0);
+        if (index >= this.length) {
+            this.length = index + 1;
+        }
+        if (this._map.has(this._array[index])) {
+            this._map.delete(this._array[index]);
+        }
+        this._array[index] = element;
+        this._map.set(element, index);
     }
-  }
-
-  resize(length) {
-    assert(length >= 0);
-    this.length = length;
-  }
-
-  trim(length) {
-    if (length === null || length === undefined) {
-      length = this.length;
+    delete(element) {
+        const index = this._map.get(element);
+        if (index >= 0) {
+            this._array.splice(index, 1);
+            this._map.delete(element);
+            this.length--;
+        }
+    }
+    /**
+     * Returns the last element in the array without modifying the array.
+     *
+     * @returns {*} The last element in the array.
+     */
+    peek() {
+        return this._array[this._length - 1];
+    }
+    /**
+     * Push an element into the array.
+     *
+     * @param {*} element The element to push.
+     */
+    push(element) {
+        if (!this._map.has(element)) {
+            const index = this.length++;
+            this._array[index] = element;
+            this._map.set(element, index);
+        }
+    }
+    /**
+     * Pop an element from the array.
+     *
+     * @returns {*} The last element in the array.
+     */
+    pop() {
+        const element = this._array[--this.length];
+        this._map.delete(element);
+        return element;
+    }
+    /**
+     * Resize the internal array if length > _array.length.
+     *
+     * @param {Number} length The length.
+     */
+    reserve(length) {
+        (0, loader_utils_1.assert)(length >= 0);
+        if (length > this._array.length) {
+            this._array.length = length;
+        }
+    }
+    /**
+     * Resize the array.
+     *
+     * @param {Number} length The length.
+     */
+    resize(length) {
+        (0, loader_utils_1.assert)(length >= 0);
+        this.length = length;
+    }
+    /**
+     * Trim the internal array to the specified length. Defaults to the current length.
+     *
+     * @param {Number} [length] The length.
+     */
+    trim(length) {
+        if (length === null || length === undefined) {
+            length = this.length;
+        }
+        this._array.length = length;
+    }
+    reset() {
+        this._array = [];
+        this._map = new Map();
+        this._length = 0;
+    }
+    find(target) {
+        return this._map.has(target);
     }
-
-    this._array.length = length;
-  }
-
-  reset() {
-    this._array = [];
-    this._map = new Map();
-    this._length = 0;
-  }
-
-  find(target) {
-    return this._map.has(target);
-  }
-
 }
-//# sourceMappingURL=managed-array.js.map
+exports.ManagedArray = ManagedArray;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/tiles",
-  "version": "4.0.0-alpha.5",
+  "version": "4.0.0-alpha.6",
   "description": "Common components for different tiles loaders.",
   "license": "MIT",
   "publishConfig": {
@@ -20,8 +20,8 @@
     "pointcloud"
   ],
   "types": "dist/index.d.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "sideEffects": false,
   "files": [
     "src",
@@ -33,16 +33,16 @@
     "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js"
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "4.0.0-alpha.5",
-    "@loaders.gl/math": "4.0.0-alpha.5",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.6",
+    "@loaders.gl/math": "4.0.0-alpha.6",
     "@math.gl/core": "^3.5.1",
     "@math.gl/culling": "^3.5.1",
     "@math.gl/geospatial": "^3.5.1",
     "@math.gl/web-mercator": "^3.5.1",
-    "@probe.gl/stats": "^3.5.0"
+    "@probe.gl/stats": "^4.0.2"
   },
   "peerDependencies": {
-    "@loaders.gl/core": "4.0.0-alpha.4"
+    "@loaders.gl/core": "4.0.0-alpha.5"
   },
-  "gitHead": "7a71a54bdf1ddf985cc3af3db90b82e7fa97d025"
+  "gitHead": "acc1985050dfaa0f1f0c066f8da5bce7454a046c"
 }

package/src/constants.ts

@@ -1,3 +1,5 @@
+// loaders.gl, MIT license
+
 export const TILE_CONTENT_STATE = {
   UNLOADED: 0, // Has never been requested
   LOADING: 1, // Is waiting on a pending request

package/src/index.ts

@@ -1,9 +1,11 @@
+// loaders.gl, MIT license
+
 export type {Tileset3DProps} from './tileset/tileset-3d';
-export {default as Tileset3D} from './tileset/tileset-3d';
-export {default as Tile3D} from './tileset/tile-3d';
+export {Tileset3D} from './tileset/tileset-3d';
+export {Tile3D} from './tileset/tile-3d';
 
-export {default as TilesetTraverser} from './tileset/traversers/tileset-traverser';
-export {default as TilesetCache} from './tileset/tileset-cache';
+export {TilesetTraverser} from './tileset/tileset-traverser';
+export {TilesetCache} from './tileset/tileset-cache';
 
 export {createBoundingVolume} from './tileset/helpers/bounding-volume';
 export {calculateTransformProps} from './tileset/helpers/transform-utils';

package/src/tileset/{traversers → format-3d-tiles}/tileset-3d-traverser.ts

@@ -1,10 +1,12 @@
+// loaders.gl, MIT license
+
 // 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
 
 import {TILE3D_OPTIMIZATION_HINT, TILE_REFINEMENT} from '../../constants';
-import TilesetTraverser from './tileset-traverser';
+import {TilesetTraverser} from '../tileset-traverser';
 
-export default class Tileset3DTraverser extends TilesetTraverser {
+export class Tileset3DTraverser extends TilesetTraverser {
   compareDistanceToCamera(a, b) {
     // Sort by farthest child first since this is going on a stack
     return b._distanceToCamera === 0 && a._distanceToCamera === 0

package/src/tileset/format-i3s/i3s-pending-tiles-register.ts

@@ -0,0 +1,44 @@
+/**
+ * Counter to register pending tile headers for the particular frameNumber
+ * Until all tiles are loaded we won't call `onTraversalEnd` callback
+ */
+export class I3SPendingTilesRegister {
+  private frameNumberMap: Map<string, Map<number, number>> = new Map();
+
+  /**
+   * Register a new pending tile header for the particular frameNumber
+   * @param viewportId
+   * @param frameNumber
+   */
+  register(viewportId: string, frameNumber: number) {
+    const viewportMap = this.frameNumberMap.get(viewportId) || new Map();
+    const oldCount = viewportMap.get(frameNumber) || 0;
+    viewportMap.set(frameNumber, oldCount + 1);
+    this.frameNumberMap.set(viewportId, viewportMap);
+  }
+
+  /**
+   * Deregister a pending tile header for the particular frameNumber
+   * @param viewportId
+   * @param frameNumber
+   */
+  deregister(viewportId: string, frameNumber: number) {
+    const viewportMap = this.frameNumberMap.get(viewportId);
+    if (!viewportMap) {
+      return;
+    }
+    const oldCount = viewportMap.get(frameNumber) || 1;
+    viewportMap.set(frameNumber, oldCount - 1);
+  }
+
+  /**
+   * Check is there are no pending tile headers registered for the particular frameNumber
+   * @param viewportId
+   * @param frameNumber
+   * @returns
+   */
+  isZero(viewportId: string, frameNumber: number) {
+    const count = this.frameNumberMap.get(viewportId)?.get(frameNumber) || 0;
+    return count === 0;
+  }
+}

package/src/tileset/format-i3s/i3s-tile-manager.ts

@@ -0,0 +1,101 @@
+import {FrameState} from '../helpers/frame-state';
+import {I3SPendingTilesRegister} from './i3s-pending-tiles-register';
+
+const STATUS = {
+  REQUESTED: 'REQUESTED',
+  COMPLETED: 'COMPLETED',
+  ERROR: 'ERROR'
+};
+
+// A helper class to manage tile metadata fetching
+export class I3STileManager {
+  private _statusMap: object;
+  private pendingTilesRegister = new I3SPendingTilesRegister();
+
+  constructor() {
+    this._statusMap = {};
+  }
+
+  /**
+   * Add request to map
+   * @param request - node metadata request
+   * @param key - unique key
+   * @param callback - callback after request completed
+   * @param frameState - frameState data
+   */
+  add(request, key, callback, frameState: FrameState) {
+    if (!this._statusMap[key]) {
+      const {
+        frameNumber,
+        viewport: {id}
+      } = frameState;
+      this._statusMap[key] = {request, callback, key, frameState, status: STATUS.REQUESTED};
+      // Register pending request for the frameNumber
+      this.pendingTilesRegister.register(id, frameNumber);
+      request()
+        .then((data) => {
+          this._statusMap[key].status = STATUS.COMPLETED;
+          const {
+            frameNumber: actualFrameNumber,
+            viewport: {id}
+          } = this._statusMap[key].frameState;
+          // Deregister pending request for the frameNumber
+          this.pendingTilesRegister.deregister(id, actualFrameNumber);
+          this._statusMap[key].callback(data, frameState);
+        })
+        .catch((error) => {
+          this._statusMap[key].status = STATUS.ERROR;
+          const {
+            frameNumber: actualFrameNumber,
+            viewport: {id}
+          } = this._statusMap[key].frameState;
+          // Deregister pending request for the frameNumber
+          this.pendingTilesRegister.deregister(id, actualFrameNumber);
+          callback(error);
+        });
+    }
+  }
+
+  /**
+   * Update request if it is still actual for the new frameState
+   * @param key - unique key
+   * @param frameState - frameState data
+   */
+  update(key, frameState: FrameState) {
+    if (this._statusMap[key]) {
+      // Deregister pending request for the old frameNumber
+      const {
+        frameNumber,
+        viewport: {id}
+      } = this._statusMap[key].frameState;
+      this.pendingTilesRegister.deregister(id, frameNumber);
+
+      // Register pending request for the new frameNumber
+      const {
+        frameNumber: newFrameNumber,
+        viewport: {id: newViewportId}
+      } = frameState;
+      this.pendingTilesRegister.register(newViewportId, newFrameNumber);
+      this._statusMap[key].frameState = frameState;
+    }
+  }
+
+  /**
+   * Find request in the map
+   * @param key - unique key
+   * @returns
+   */
+  find(key) {
+    return this._statusMap[key];
+  }
+
+  /**
+   * Check it there are pending tile headers for the particular frameNumber
+   * @param viewportId
+   * @param frameNumber
+   * @returns
+   */
+  hasPendingTiles(viewportId: string, frameNumber: number): boolean {
+    return !this.pendingTilesRegister.isZero(viewportId, frameNumber);
+  }
+}