@loaders.gl/tiles 3.1.0-beta.7 → 3.1.0

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

@@ -7,25 +7,40 @@ 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");
 
-const DEFAULT_PROPS = {
+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 = {
   loadSiblings: false,
   skipLevelOfDetail: false,
   maximumScreenSpaceError: 2,
   updateTransforms: true,
-  onTraversalEnd: () => {},
+  onTraversalEnd: function onTraversalEnd() {},
   viewportTraversersMap: {},
   basePath: ''
 };
 exports.DEFAULT_PROPS = DEFAULT_PROPS;
 
-class TilesetTraverser {
-  constructor(options) {
+var TilesetTraverser = function () {
+  function TilesetTraverser(options) {
+    (0, _classCallCheck2.default)(this, TilesetTraverser);
     (0, _defineProperty2.default)(this, "options", void 0);
     (0, _defineProperty2.default)(this, "root", void 0);
     (0, _defineProperty2.default)(this, "requestedTiles", void 0);
@@ -34,9 +49,7 @@ class TilesetTraverser {
     (0, _defineProperty2.default)(this, "_traversalStack", void 0);
     (0, _defineProperty2.default)(this, "_emptyTraversalStack", void 0);
     (0, _defineProperty2.default)(this, "_frameNumber", void 0);
-    this.options = { ...DEFAULT_PROPS,
-      ...options
-    };
+    this.options = _objectSpread(_objectSpread({}, DEFAULT_PROPS), options);
     this._traversalStack = new _managedArray.default();
     this._emptyTraversalStack = new _managedArray.default();
     this._frameNumber = null;
@@ -46,259 +59,319 @@ class TilesetTraverser {
     this.emptyTiles = {};
   }
 
-  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);
-  }
-
-  reset() {
-    this.requestedTiles = {};
-    this.selectedTiles = {};
-    this.emptyTiles = {};
-
-    this._traversalStack.reset();
-
-    this._emptyTraversalStack.reset();
-  }
-
-  executeTraversal(root, frameState) {
-    const stack = this._traversalStack;
-    root._selectionDepth = 1;
-    stack.push(root);
+  (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 = {};
 
-    while (stack.length > 0) {
-      const tile = stack.pop();
-      let shouldRefine = false;
+      this._traversalStack.reset();
 
-      if (this.canTraverse(tile, frameState)) {
-        this.updateChildTiles(tile, frameState);
-        shouldRefine = this.updateAndPushChildren(tile, frameState, stack, tile.hasRenderContent ? tile._selectionDepth + 1 : tile._selectionDepth);
-      }
+      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);
+        }
 
-      const parent = tile.parent;
-      const parentRefines = Boolean(!parent || parent._shouldRefine);
-      const stoppedRefining = !shouldRefine;
+        var parent = tile.parent;
+        var parentRefines = Boolean(!parent || parent._shouldRefine);
+        var stoppedRefining = !shouldRefine;
 
-      if (!tile.hasRenderContent) {
-        this.emptyTiles[tile.id] = tile;
-        this.loadTile(tile, frameState);
+        if (!tile.hasRenderContent) {
+          this.emptyTiles[tile.id] = tile;
+          this.loadTile(tile, frameState);
 
-        if (stoppedRefining) {
+          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.ADD) {
-        this.loadTile(tile, frameState);
-        this.selectTile(tile, frameState);
-      } else if (tile.refine === _constants.TILE_REFINEMENT.REPLACE) {
-        this.loadTile(tile, frameState);
+        } else if (tile.refine === _constants.TILE_REFINEMENT.REPLACE) {
+          this.loadTile(tile, frameState);
 
-        if (stoppedRefining) {
-          this.selectTile(tile, frameState);
+          if (stoppedRefining) {
+            this.selectTile(tile, frameState);
+          }
         }
+
+        this.touchTile(tile, frameState);
+        tile._shouldRefine = shouldRefine && parentRefines;
       }
 
-      this.touchTile(tile, frameState);
-      tile._shouldRefine = shouldRefine && parentRefines;
+      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);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
 
-    this.options.onTraversalEnd(frameState);
-  }
-
-  updateChildTiles(tile, frameState) {
-    const children = tile.children;
-
-    for (const child of children) {
-      this.updateTile(child, frameState);
+      return true;
     }
+  }, {
+    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);
+          }
 
-    return true;
-  }
+          if (checkRefines) {
+            var childRefines = void 0;
 
-  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);
-        }
+            if (!child._inRequestVolume) {
+              childRefines = false;
+            } else if (!child.hasRenderContent) {
+              childRefines = this.executeEmptyTraversal(child, frameState);
+            } else {
+              childRefines = child.contentAvailable;
+            }
 
-        stack.push(child);
-        hasVisibleChild = true;
-      } else if (checkRefines || loadSiblings) {
-        this.loadTile(child, frameState);
-        this.touchTile(child, frameState);
-      }
-
-      if (checkRefines) {
-        let childRefines;
+            refines = refines && childRefines;
 
-        if (!child._inRequestVolume) {
-          childRefines = false;
-        } else if (!child.hasRenderContent) {
-          childRefines = this.executeEmptyTraversal(child, frameState);
-        } else {
-          childRefines = child.contentAvailable;
+            if (!refines) {
+              return false;
+            }
+          }
         }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
 
-        refines = refines && childRefines;
-
-        if (!refines) {
-          return false;
-        }
+      if (!hasVisibleChild) {
+        refines = false;
       }
-    }
 
-    if (!hasVisibleChild) {
-      refines = false;
+      return refines;
     }
-
-    return refines;
-  }
-
-  updateTile(tile, frameState) {
-    this.updateTileVisibility(tile, frameState);
-  }
-
-  selectTile(tile, frameState) {
-    if (this.shouldSelectTile(tile)) {
-      tile._selectedFrame = frameState.frameNumber;
-      this.selectedTiles[tile.id] = tile;
+  }, {
+    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;
+      }
+    }
+  }, {
+    key: "touchTile",
+    value: function touchTile(tile, frameState) {
+      tile.tileset._cache.touch(tile);
 
-  loadTile(tile, frameState) {
-    if (this.shouldLoadTile(tile)) {
-      tile._requestedFrame = frameState.frameNumber;
-      tile._priority = tile._getPriority();
-      this.requestedTiles[tile.id] = tile;
+      tile._touchedFrame = frameState.frameNumber;
     }
-  }
+  }, {
+    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;
+      }
 
-  touchTile(tile, frameState) {
-    tile.tileset._cache.touch(tile);
+      if (tile.hasTilesetContent) {
+        return !tile.contentExpired;
+      }
 
-    tile._touchedFrame = frameState.frameNumber;
-  }
+      if (!ignoreVisibility && !tile.isVisibleAndInRequestVolume) {
+        return false;
+      }
 
-  canTraverse(tile, frameState, useParentMetric = false, ignoreVisibility = false) {
-    if (!tile.hasChildren) {
-      return false;
+      return this.shouldRefine(tile, frameState, useParentMetric);
     }
-
-    if (tile.hasTilesetContent) {
-      return !tile.contentExpired;
+  }, {
+    key: "shouldLoadTile",
+    value: function shouldLoadTile(tile) {
+      return tile.hasUnloadedContent || tile.contentExpired;
     }
-
-    if (!ignoreVisibility && !tile.isVisibleAndInRequestVolume) {
-      return false;
+  }, {
+    key: "shouldSelectTile",
+    value: function shouldSelectTile(tile) {
+      return tile.contentAvailable && !this.options.skipLevelOfDetail;
     }
+  }, {
+    key: "shouldRefine",
+    value: function shouldRefine(tile, frameState, useParentMetric) {
+      var screenSpaceError = tile._screenSpaceError;
 
-    return this.shouldRefine(tile, frameState, useParentMetric);
-  }
-
-  shouldLoadTile(tile) {
-    return tile.hasUnloadedContent || tile.contentExpired;
-  }
-
-  shouldSelectTile(tile) {
-    return tile.contentAvailable && !this.options.skipLevelOfDetail;
-  }
-
-  shouldRefine(tile, frameState, useParentMetric) {
-    let screenSpaceError = tile._screenSpaceError;
+      if (useParentMetric) {
+        screenSpaceError = tile.getScreenSpaceError(frameState, true);
+      }
 
-    if (useParentMetric) {
-      screenSpaceError = tile.getScreenSpaceError(frameState, true);
+      return screenSpaceError > this.options.maximumScreenSpaceError;
     }
+  }, {
+    key: "updateTileVisibility",
+    value: function updateTileVisibility(tile, frameState) {
+      var viewportIds = [];
 
-    return screenSpaceError > this.options.maximumScreenSpaceError;
-  }
+      if (this.options.viewportTraversersMap) {
+        for (var _key in this.options.viewportTraversersMap) {
+          var value = this.options.viewportTraversersMap[_key];
 
-  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);
+          if (value === frameState.viewport.id) {
+            viewportIds.push(_key);
+          }
         }
+      } else {
+        viewportIds.push(frameState.viewport.id);
       }
-    } else {
-      viewportIds.push(frameState.viewport.id);
-    }
-
-    tile.updateVisibility(frameState, viewportIds);
-  }
 
-  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;
+      tile.updateVisibility(frameState, viewportIds);
     }
+  }, {
+    key: "compareDistanceToCamera",
+    value: function compareDistanceToCamera(b, a) {
+      return b._distanceToCamera - a._distanceToCamera;
+    }
+  }, {
+    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;
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
 
-    return anyVisible;
-  }
+      return anyVisible;
+    }
+  }, {
+    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);
+        }
 
-  executeEmptyTraversal(root, frameState) {
-    let allDescendantsLoaded = true;
-    const stack = this._emptyTraversalStack;
-    stack.push(root);
+        this.touchTile(tile, frameState);
+        var traverse = !tile.hasRenderContent && this.canTraverse(tile, frameState, false, true);
 
-    while (stack.length > 0 && allDescendantsLoaded) {
-      const tile = stack.pop();
-      this.updateTile(tile, frameState);
+        if (traverse) {
+          var children = tile.children;
 
-      if (!tile.isVisibleAndInRequestVolume) {
-        this.loadTile(tile, frameState);
-      }
+          var _iterator4 = _createForOfIteratorHelper(children),
+              _step4;
 
-      this.touchTile(tile, frameState);
-      const traverse = !tile.hasRenderContent && this.canTraverse(tile, frameState, false, true);
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var child = _step4.value;
 
-      if (traverse) {
-        const children = tile.children;
+              if (stack.find(child)) {
+                stack.delete(child);
+              }
 
-        for (const child of children) {
-          if (stack.find(child)) {
-            stack.delete(child);
+              stack.push(child);
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
           }
-
-          stack.push(child);
+        } else if (!tile.contentAvailable) {
+          allDescendantsLoaded = false;
         }
-      } else if (!tile.contentAvailable) {
-        allDescendantsLoaded = false;
       }
-    }
 
-    return allDescendantsLoaded;
-  }
-
-}
+      return allDescendantsLoaded;
+    }
+  }]);
+  return TilesetTraverser;
+}();
 
 exports.default = TilesetTraverser;
 //# sourceMappingURL=tileset-traverser.js.map