@loaders.gl/tiles 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/es5/tileset/traversers/tileset-traverser.js

@@ -7,40 +7,25 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = exports.DEFAULT_PROPS = void 0;
 
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _managedArray = _interopRequireDefault(require("../../utils/managed-array"));
 
 var _constants = require("../../constants");
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-var DEFAULT_PROPS = {
+const DEFAULT_PROPS = {
   loadSiblings: false,
   skipLevelOfDetail: false,
   maximumScreenSpaceError: 2,
   updateTransforms: true,
-  onTraversalEnd: function onTraversalEnd() {},
+  onTraversalEnd: () => {},
   viewportTraversersMap: {},
   basePath: ''
 };
 exports.DEFAULT_PROPS = DEFAULT_PROPS;
 
-var TilesetTraverser = function () {
-  function TilesetTraverser(options) {
-    (0, _classCallCheck2.default)(this, TilesetTraverser);
+class TilesetTraverser {
+  constructor(options) {
     (0, _defineProperty2.default)(this, "options", void 0);
     (0, _defineProperty2.default)(this, "root", void 0);
     (0, _defineProperty2.default)(this, "requestedTiles", void 0);
@@ -49,7 +34,9 @@ var TilesetTraverser = function () {
     (0, _defineProperty2.default)(this, "_traversalStack", void 0);
     (0, _defineProperty2.default)(this, "_emptyTraversalStack", void 0);
     (0, _defineProperty2.default)(this, "_frameNumber", void 0);
-    this.options = _objectSpread(_objectSpread({}, DEFAULT_PROPS), options);
+    this.options = { ...DEFAULT_PROPS,
+      ...options
+    };
     this._traversalStack = new _managedArray.default();
     this._emptyTraversalStack = new _managedArray.default();
     this._frameNumber = null;
@@ -59,319 +46,259 @@ var TilesetTraverser = function () {
     this.emptyTiles = {};
   }
 
-  (0, _createClass2.default)(TilesetTraverser, [{
-    key: "traverse",
-    value: function traverse(root, frameState, options) {
-      this.root = root;
-      this.options = _objectSpread(_objectSpread({}, this.options), options);
-      this.reset();
-      this.updateTile(root, frameState);
-      this._frameNumber = frameState.frameNumber;
-      this.executeTraversal(root, frameState);
-    }
-  }, {
-    key: "reset",
-    value: function reset() {
-      this.requestedTiles = {};
-      this.selectedTiles = {};
-      this.emptyTiles = {};
-
-      this._traversalStack.reset();
+  traverse(root, frameState, options) {
+    this.root = root;
+    this.options = { ...this.options,
+      ...options
+    };
+    this.reset();
+    this.updateTile(root, frameState);
+    this._frameNumber = frameState.frameNumber;
+    this.executeTraversal(root, frameState);
+  }
 
-      this._emptyTraversalStack.reset();
-    }
-  }, {
-    key: "executeTraversal",
-    value: function executeTraversal(root, frameState) {
-      var stack = this._traversalStack;
-      root._selectionDepth = 1;
-      stack.push(root);
-
-      while (stack.length > 0) {
-        var tile = stack.pop();
-        var shouldRefine = false;
-
-        if (this.canTraverse(tile, frameState)) {
-          this.updateChildTiles(tile, frameState);
-          shouldRefine = this.updateAndPushChildren(tile, frameState, stack, tile.hasRenderContent ? tile._selectionDepth + 1 : tile._selectionDepth);
-        }
+  reset() {
+    this.requestedTiles = {};
+    this.selectedTiles = {};
+    this.emptyTiles = {};
 
-        var parent = tile.parent;
-        var parentRefines = Boolean(!parent || parent._shouldRefine);
-        var stoppedRefining = !shouldRefine;
+    this._traversalStack.reset();
 
-        if (!tile.hasRenderContent) {
-          this.emptyTiles[tile.id] = tile;
-          this.loadTile(tile, frameState);
+    this._emptyTraversalStack.reset();
+  }
 
-          if (stoppedRefining) {
-            this.selectTile(tile, frameState);
-          }
-        } else if (tile.refine === _constants.TILE_REFINEMENT.ADD) {
-          this.loadTile(tile, frameState);
-          this.selectTile(tile, frameState);
-        } else if (tile.refine === _constants.TILE_REFINEMENT.REPLACE) {
-          this.loadTile(tile, frameState);
+  executeTraversal(root, frameState) {
+    const stack = this._traversalStack;
+    root._selectionDepth = 1;
+    stack.push(root);
 
-          if (stoppedRefining) {
-            this.selectTile(tile, frameState);
-          }
-        }
+    while (stack.length > 0) {
+      const tile = stack.pop();
+      let shouldRefine = false;
 
-        this.touchTile(tile, frameState);
-        tile._shouldRefine = shouldRefine && parentRefines;
+      if (this.canTraverse(tile, frameState)) {
+        this.updateChildTiles(tile, frameState);
+        shouldRefine = this.updateAndPushChildren(tile, frameState, stack, tile.hasRenderContent ? tile._selectionDepth + 1 : tile._selectionDepth);
       }
 
-      this.options.onTraversalEnd(frameState);
-    }
-  }, {
-    key: "updateChildTiles",
-    value: function updateChildTiles(tile, frameState) {
-      var children = tile.children;
-
-      var _iterator = _createForOfIteratorHelper(children),
-          _step;
-
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var child = _step.value;
-          this.updateTile(child, frameState);
+      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);
+        }
+      } else if (tile.refine === _constants.TILE_REFINEMENT.ADD) {
+        this.loadTile(tile, frameState);
+        this.selectTile(tile, frameState);
+      } else if (tile.refine === _constants.TILE_REFINEMENT.REPLACE) {
+        this.loadTile(tile, frameState);
+
+        if (stoppedRefining) {
+          this.selectTile(tile, frameState);
         }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
       }
 
-      return true;
+      this.touchTile(tile, frameState);
+      tile._shouldRefine = shouldRefine && parentRefines;
     }
-  }, {
-    key: "updateAndPushChildren",
-    value: function updateAndPushChildren(tile, frameState, stack, depth) {
-      var _this$options = this.options,
-          loadSiblings = _this$options.loadSiblings,
-          skipLevelOfDetail = _this$options.skipLevelOfDetail;
-      var children = tile.children;
-      children.sort(this.compareDistanceToCamera.bind(this));
-      var checkRefines = tile.refine === _constants.TILE_REFINEMENT.REPLACE && tile.hasRenderContent && !skipLevelOfDetail;
-      var hasVisibleChild = false;
-      var refines = true;
-
-      var _iterator2 = _createForOfIteratorHelper(children),
-          _step2;
-
-      try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var child = _step2.value;
-          child._selectionDepth = depth;
-
-          if (child.isVisibleAndInRequestVolume) {
-            if (stack.find(child)) {
-              stack.delete(child);
-            }
-
-            stack.push(child);
-            hasVisibleChild = true;
-          } else if (checkRefines || loadSiblings) {
-            this.loadTile(child, frameState);
-            this.touchTile(child, frameState);
-          }
 
-          if (checkRefines) {
-            var childRefines = void 0;
+    this.options.onTraversalEnd(frameState);
+  }
 
-            if (!child._inRequestVolume) {
-              childRefines = false;
-            } else if (!child.hasRenderContent) {
-              childRefines = this.executeEmptyTraversal(child, frameState);
-            } else {
-              childRefines = child.contentAvailable;
-            }
+  updateChildTiles(tile, frameState) {
+    const children = tile.children;
 
-            refines = refines && childRefines;
+    for (const child of children) {
+      this.updateTile(child, frameState);
+    }
 
-            if (!refines) {
-              return false;
-            }
-          }
+    return true;
+  }
+
+  updateAndPushChildren(tile, frameState, stack, depth) {
+    const {
+      loadSiblings,
+      skipLevelOfDetail
+    } = this.options;
+    const children = tile.children;
+    children.sort(this.compareDistanceToCamera.bind(this));
+    const checkRefines = tile.refine === _constants.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);
         }
-      } catch (err) {
-        _iterator2.e(err);
-      } finally {
-        _iterator2.f();
-      }
 
-      if (!hasVisibleChild) {
-        refines = false;
+        stack.push(child);
+        hasVisibleChild = true;
+      } else if (checkRefines || loadSiblings) {
+        this.loadTile(child, frameState);
+        this.touchTile(child, frameState);
       }
 
-      return refines;
-    }
-  }, {
-    key: "updateTile",
-    value: function updateTile(tile, frameState) {
-      this.updateTileVisibility(tile, frameState);
-    }
-  }, {
-    key: "selectTile",
-    value: function selectTile(tile, frameState) {
-      if (this.shouldSelectTile(tile)) {
-        tile._selectedFrame = frameState.frameNumber;
-        this.selectedTiles[tile.id] = tile;
-      }
-    }
-  }, {
-    key: "loadTile",
-    value: function loadTile(tile, frameState) {
-      if (this.shouldLoadTile(tile)) {
-        tile._requestedFrame = frameState.frameNumber;
-        tile._priority = tile._getPriority();
-        this.requestedTiles[tile.id] = tile;
+      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;
+        }
       }
     }
-  }, {
-    key: "touchTile",
-    value: function touchTile(tile, frameState) {
-      tile.tileset._cache.touch(tile);
 
-      tile._touchedFrame = frameState.frameNumber;
+    if (!hasVisibleChild) {
+      refines = false;
     }
-  }, {
-    key: "canTraverse",
-    value: function canTraverse(tile, frameState) {
-      var useParentMetric = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-      var ignoreVisibility = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-
-      if (!tile.hasChildren) {
-        return false;
-      }
 
-      if (tile.hasTilesetContent) {
-        return !tile.contentExpired;
-      }
+    return refines;
+  }
 
-      if (!ignoreVisibility && !tile.isVisibleAndInRequestVolume) {
-        return false;
-      }
+  updateTile(tile, frameState) {
+    this.updateTileVisibility(tile, frameState);
+  }
 
-      return this.shouldRefine(tile, frameState, useParentMetric);
+  selectTile(tile, frameState) {
+    if (this.shouldSelectTile(tile)) {
+      tile._selectedFrame = frameState.frameNumber;
+      this.selectedTiles[tile.id] = tile;
     }
-  }, {
-    key: "shouldLoadTile",
-    value: function shouldLoadTile(tile) {
-      return tile.hasUnloadedContent || tile.contentExpired;
+  }
+
+  loadTile(tile, frameState) {
+    if (this.shouldLoadTile(tile)) {
+      tile._requestedFrame = frameState.frameNumber;
+      tile._priority = tile._getPriority();
+      this.requestedTiles[tile.id] = tile;
     }
-  }, {
-    key: "shouldSelectTile",
-    value: function shouldSelectTile(tile) {
-      return tile.contentAvailable && !this.options.skipLevelOfDetail;
+  }
+
+  touchTile(tile, frameState) {
+    tile.tileset._cache.touch(tile);
+
+    tile._touchedFrame = frameState.frameNumber;
+  }
+
+  canTraverse(tile, frameState, useParentMetric = false, ignoreVisibility = false) {
+    if (!tile.hasChildren) {
+      return false;
     }
-  }, {
-    key: "shouldRefine",
-    value: function shouldRefine(tile, frameState, useParentMetric) {
-      var screenSpaceError = tile._screenSpaceError;
 
-      if (useParentMetric) {
-        screenSpaceError = tile.getScreenSpaceError(frameState, true);
-      }
+    if (tile.hasTilesetContent) {
+      return !tile.contentExpired;
+    }
 
-      return screenSpaceError > this.options.maximumScreenSpaceError;
+    if (!ignoreVisibility && !tile.isVisibleAndInRequestVolume) {
+      return false;
     }
-  }, {
-    key: "updateTileVisibility",
-    value: function updateTileVisibility(tile, frameState) {
-      var viewportIds = [];
 
-      if (this.options.viewportTraversersMap) {
-        for (var _key in this.options.viewportTraversersMap) {
-          var value = this.options.viewportTraversersMap[_key];
+    return this.shouldRefine(tile, frameState, useParentMetric);
+  }
 
-          if (value === frameState.viewport.id) {
-            viewportIds.push(_key);
-          }
-        }
-      } else {
-        viewportIds.push(frameState.viewport.id);
-      }
+  shouldLoadTile(tile) {
+    return tile.hasUnloadedContent || tile.contentExpired;
+  }
 
-      tile.updateVisibility(frameState, viewportIds);
-    }
-  }, {
-    key: "compareDistanceToCamera",
-    value: function compareDistanceToCamera(b, a) {
-      return b._distanceToCamera - a._distanceToCamera;
+  shouldSelectTile(tile) {
+    return tile.contentAvailable && !this.options.skipLevelOfDetail;
+  }
+
+  shouldRefine(tile, frameState, useParentMetric) {
+    let screenSpaceError = tile._screenSpaceError;
+
+    if (useParentMetric) {
+      screenSpaceError = tile.getScreenSpaceError(frameState, true);
     }
-  }, {
-    key: "anyChildrenVisible",
-    value: function anyChildrenVisible(tile, frameState) {
-      var anyVisible = false;
-
-      var _iterator3 = _createForOfIteratorHelper(tile.children),
-          _step3;
-
-      try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var child = _step3.value;
-          child.updateVisibility(frameState);
-          anyVisible = anyVisible || child.isVisibleAndInRequestVolume;
+
+    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);
         }
-      } catch (err) {
-        _iterator3.e(err);
-      } finally {
-        _iterator3.f();
       }
+    } else {
+      viewportIds.push(frameState.viewport.id);
+    }
+
+    tile.updateVisibility(frameState, viewportIds);
+  }
+
+  compareDistanceToCamera(b, a) {
+    return b._distanceToCamera - a._distanceToCamera;
+  }
 
-      return anyVisible;
+  anyChildrenVisible(tile, frameState) {
+    let anyVisible = false;
+
+    for (const child of tile.children) {
+      child.updateVisibility(frameState);
+      anyVisible = anyVisible || child.isVisibleAndInRequestVolume;
     }
-  }, {
-    key: "executeEmptyTraversal",
-    value: function executeEmptyTraversal(root, frameState) {
-      var allDescendantsLoaded = true;
-      var stack = this._emptyTraversalStack;
-      stack.push(root);
-
-      while (stack.length > 0 && allDescendantsLoaded) {
-        var tile = stack.pop();
-        this.updateTile(tile, frameState);
-
-        if (!tile.isVisibleAndInRequestVolume) {
-          this.loadTile(tile, frameState);
-        }
 
-        this.touchTile(tile, frameState);
-        var traverse = !tile.hasRenderContent && this.canTraverse(tile, frameState, false, true);
+    return anyVisible;
+  }
 
-        if (traverse) {
-          var children = tile.children;
+  executeEmptyTraversal(root, frameState) {
+    let allDescendantsLoaded = true;
+    const stack = this._emptyTraversalStack;
+    stack.push(root);
 
-          var _iterator4 = _createForOfIteratorHelper(children),
-              _step4;
+    while (stack.length > 0 && allDescendantsLoaded) {
+      const tile = stack.pop();
+      this.updateTile(tile, frameState);
+
+      if (!tile.isVisibleAndInRequestVolume) {
+        this.loadTile(tile, frameState);
+      }
 
-          try {
-            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-              var child = _step4.value;
+      this.touchTile(tile, frameState);
+      const traverse = !tile.hasRenderContent && this.canTraverse(tile, frameState, false, true);
 
-              if (stack.find(child)) {
-                stack.delete(child);
-              }
+      if (traverse) {
+        const children = tile.children;
 
-              stack.push(child);
-            }
-          } catch (err) {
-            _iterator4.e(err);
-          } finally {
-            _iterator4.f();
+        for (const child of children) {
+          if (stack.find(child)) {
+            stack.delete(child);
           }
-        } else if (!tile.contentAvailable) {
-          allDescendantsLoaded = false;
+
+          stack.push(child);
         }
+      } else if (!tile.contentAvailable) {
+        allDescendantsLoaded = false;
       }
-
-      return allDescendantsLoaded;
     }
-  }]);
-  return TilesetTraverser;
-}();
+
+    return allDescendantsLoaded;
+  }
+
+}
 
 exports.default = TilesetTraverser;
 //# sourceMappingURL=tileset-traverser.js.map