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

package/dist/es5/tileset/tileset-3d.js

@@ -7,6 +7,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+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 _core = require("@math.gl/core");
@@ -35,17 +43,29 @@ var _i3sTilesetTraverser = _interopRequireDefault(require("./traversers/i3s-tile
 
 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 = {
   description: '',
   ellipsoid: _geospatial.Ellipsoid.WGS84,
   modelMatrix: new _core.Matrix4(),
   throttleRequests: true,
   maxRequests: 64,
   maximumMemoryUsage: 32,
-  onTileLoad: () => {},
-  onTileUnload: () => {},
-  onTileError: () => {},
-  onTraversalComplete: selectedTiles => selectedTiles,
+  onTileLoad: function onTileLoad() {},
+  onTileUnload: function onTileUnload() {},
+  onTileError: function onTileError() {},
+  onTraversalComplete: function onTraversalComplete(selectedTiles) {
+    return selectedTiles;
+  },
   contentLoader: undefined,
   viewDistanceScale: 1.0,
   maximumScreenSpaceError: 8,
@@ -59,19 +79,20 @@ const DEFAULT_PROPS = {
   basePath: '',
   i3s: {}
 };
-const TILES_TOTAL = 'Tiles In Tileset(s)';
-const TILES_IN_MEMORY = 'Tiles In Memory';
-const TILES_IN_VIEW = 'Tiles In View';
-const TILES_RENDERABLE = 'Tiles To Render';
-const TILES_LOADED = 'Tiles Loaded';
-const TILES_LOADING = 'Tiles Loading';
-const TILES_UNLOADED = 'Tiles Unloaded';
-const TILES_LOAD_FAILED = 'Failed Tile Loads';
-const POINTS_COUNT = 'Points';
-const TILES_GPU_MEMORY = 'Tile Memory Use';
-
-class Tileset3D {
-  constructor(json, options) {
+var TILES_TOTAL = 'Tiles In Tileset(s)';
+var TILES_IN_MEMORY = 'Tiles In Memory';
+var TILES_IN_VIEW = 'Tiles In View';
+var TILES_RENDERABLE = 'Tiles To Render';
+var TILES_LOADED = 'Tiles Loaded';
+var TILES_LOADING = 'Tiles Loading';
+var TILES_UNLOADED = 'Tiles Unloaded';
+var TILES_LOAD_FAILED = 'Failed Tile Loads';
+var POINTS_COUNT = 'Points';
+var TILES_GPU_MEMORY = 'Tile Memory Use';
+
+var Tileset3D = function () {
+  function Tileset3D(json, options) {
+    (0, _classCallCheck2.default)(this, Tileset3D);
     (0, _defineProperty2.default)(this, "options", void 0);
     (0, _defineProperty2.default)(this, "loadOptions", void 0);
     (0, _defineProperty2.default)(this, "type", void 0);
@@ -117,9 +138,7 @@ class Tileset3D {
     (0, _defineProperty2.default)(this, "frameStateData", void 0);
     (0, _defineProperty2.default)(this, "maximumMemoryUsage", void 0);
     (0, _loaderUtils.assert)(json);
-    this.options = { ...DEFAULT_PROPS,
-      ...options
-    };
+    this.options = _objectSpread(_objectSpread({}, DEFAULT_PROPS), options);
     this.tileset = json;
     this.loader = json.loader;
     this.type = json.type;
@@ -173,473 +192,636 @@ class Tileset3D {
     this._initializeTileSet(json);
   }
 
-  destroy() {
-    this._destroy();
-  }
-
-  isLoaded() {
-    return this._pendingCount === 0 && this._frameNumber !== 0;
-  }
-
-  get tiles() {
-    return Object.values(this._tiles);
-  }
-
-  get frameNumber() {
-    return this._frameNumber;
-  }
-
-  get queryParams() {
-    if (!this._queryParamsString) {
-      this._queryParamsString = getQueryParamString(this._queryParams);
+  (0, _createClass2.default)(Tileset3D, [{
+    key: "destroy",
+    value: function destroy() {
+      this._destroy();
     }
-
-    return this._queryParamsString;
-  }
-
-  setProps(props) {
-    this.options = { ...this.options,
-      ...props
-    };
-  }
-
-  setOptions(options) {
-    this.options = { ...this.options,
-      ...options
-    };
-  }
-
-  getTileUrl(tilePath) {
-    const isDataUrl = tilePath.startsWith('data:');
-
-    if (isDataUrl) {
-      return tilePath;
+  }, {
+    key: "isLoaded",
+    value: function isLoaded() {
+      return this._pendingCount === 0 && this._frameNumber !== 0;
     }
-
-    return "".concat(tilePath).concat(this.queryParams);
-  }
-
-  hasExtension(extensionName) {
-    return Boolean(this._extensionsUsed && this._extensionsUsed.indexOf(extensionName) > -1);
-  }
-
-  update(viewports) {
-    if ('loadTiles' in this.options && !this.options.loadTiles) {
-      return;
+  }, {
+    key: "tiles",
+    get: function get() {
+      return Object.values(this._tiles);
     }
-
-    if (this.traverseCounter > 0) {
-      return;
+  }, {
+    key: "frameNumber",
+    get: function get() {
+      return this._frameNumber;
     }
+  }, {
+    key: "queryParams",
+    get: function get() {
+      if (!this._queryParamsString) {
+        this._queryParamsString = getQueryParamString(this._queryParams);
+      }
 
-    if (!viewports && this.lastUpdatedVieports) {
-      viewports = this.lastUpdatedVieports;
-    } else {
-      this.lastUpdatedVieports = viewports;
+      return this._queryParamsString;
     }
-
-    if (!(viewports instanceof Array)) {
-      viewports = [viewports];
+  }, {
+    key: "setProps",
+    value: function setProps(props) {
+      this.options = _objectSpread(_objectSpread({}, this.options), props);
     }
-
-    this._cache.reset();
-
-    this._frameNumber++;
-    this.traverseCounter = viewports.length;
-    const viewportsToTraverse = [];
-
-    for (const viewport of viewports) {
-      const id = viewport.id;
-
-      if (this._needTraverse(id)) {
-        viewportsToTraverse.push(id);
-      } else {
-        this.traverseCounter--;
-      }
+  }, {
+    key: "setOptions",
+    value: function setOptions(options) {
+      this.options = _objectSpread(_objectSpread({}, this.options), options);
     }
+  }, {
+    key: "getTileUrl",
+    value: function getTileUrl(tilePath) {
+      var isDataUrl = tilePath.startsWith('data:');
 
-    for (const viewport of viewports) {
-      const id = viewport.id;
-
-      if (!this.roots[id]) {
-        this.roots[id] = this._initializeTileHeaders(this.tileset, null);
+      if (isDataUrl) {
+        return tilePath;
       }
 
-      if (!viewportsToTraverse.includes(id)) {
-        continue;
+      return "".concat(tilePath).concat(this.queryParams);
+    }
+  }, {
+    key: "hasExtension",
+    value: function hasExtension(extensionName) {
+      return Boolean(this._extensionsUsed && this._extensionsUsed.indexOf(extensionName) > -1);
+    }
+  }, {
+    key: "update",
+    value: function update(viewports) {
+      if ('loadTiles' in this.options && !this.options.loadTiles) {
+        return;
       }
 
-      const frameState = (0, _frameState.getFrameState)(viewport, this._frameNumber);
-
-      this._traverser.traverse(this.roots[id], frameState, this.options);
-    }
-  }
+      if (this.traverseCounter > 0) {
+        return;
+      }
 
-  _needTraverse(viewportId) {
-    let traverserId = viewportId;
+      if (!viewports && this.lastUpdatedVieports) {
+        viewports = this.lastUpdatedVieports;
+      } else {
+        this.lastUpdatedVieports = viewports;
+      }
 
-    if (this.options.viewportTraversersMap) {
-      traverserId = this.options.viewportTraversersMap[viewportId];
-    }
+      if (!(viewports instanceof Array)) {
+        viewports = [viewports];
+      }
 
-    if (traverserId !== viewportId) {
-      return false;
-    }
+      this._cache.reset();
 
-    return true;
-  }
+      this._frameNumber++;
+      this.traverseCounter = viewports.length;
+      var viewportsToTraverse = [];
 
-  _onTraversalEnd(frameState) {
-    const id = frameState.viewport.id;
+      var _iterator = _createForOfIteratorHelper(viewports),
+          _step;
 
-    if (!this.frameStateData[id]) {
-      this.frameStateData[id] = {
-        selectedTiles: [],
-        _requestedTiles: [],
-        _emptyTiles: []
-      };
-    }
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var viewport = _step.value;
+          var _id = viewport.id;
 
-    const currentFrameStateData = this.frameStateData[id];
-    const selectedTiles = Object.values(this._traverser.selectedTiles);
-    currentFrameStateData.selectedTiles = selectedTiles;
-    currentFrameStateData._requestedTiles = Object.values(this._traverser.requestedTiles);
-    currentFrameStateData._emptyTiles = Object.values(this._traverser.emptyTiles);
-    this.traverseCounter--;
+          if (this._needTraverse(_id)) {
+            viewportsToTraverse.push(_id);
+          } else {
+            this.traverseCounter--;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
 
-    if (this.traverseCounter > 0) {
-      return;
-    }
+      var _iterator2 = _createForOfIteratorHelper(viewports),
+          _step2;
 
-    this._updateTiles();
-  }
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _viewport = _step2.value;
+          var _id2 = _viewport.id;
 
-  _updateTiles() {
-    this.selectedTiles = [];
-    this._requestedTiles = [];
-    this._emptyTiles = [];
+          if (!this.roots[_id2]) {
+            this.roots[_id2] = this._initializeTileHeaders(this.tileset, null);
+          }
 
-    for (const frameStateKey in this.frameStateData) {
-      const frameStateDataValue = this.frameStateData[frameStateKey];
-      this.selectedTiles = this.selectedTiles.concat(frameStateDataValue.selectedTiles);
-      this._requestedTiles = this._requestedTiles.concat(frameStateDataValue._requestedTiles);
-      this._emptyTiles = this._emptyTiles.concat(frameStateDataValue._emptyTiles);
-    }
+          if (!viewportsToTraverse.includes(_id2)) {
+            continue;
+          }
 
-    this.selectedTiles = this.options.onTraversalComplete(this.selectedTiles);
+          var frameState = (0, _frameState.getFrameState)(_viewport, this._frameNumber);
 
-    for (const tile of this.selectedTiles) {
-      this._tiles[tile.id] = tile;
+          this._traverser.traverse(this.roots[_id2], frameState, this.options);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
     }
+  }, {
+    key: "_needTraverse",
+    value: function _needTraverse(viewportId) {
+      var traverserId = viewportId;
 
-    this._loadTiles();
-
-    this._unloadTiles();
+      if (this.options.viewportTraversersMap) {
+        traverserId = this.options.viewportTraversersMap[viewportId];
+      }
 
-    this._updateStats();
-  }
+      if (traverserId !== viewportId) {
+        return false;
+      }
 
-  _tilesChanged(oldSelectedTiles, selectedTiles) {
-    if (oldSelectedTiles.length !== selectedTiles.length) {
       return true;
     }
+  }, {
+    key: "_onTraversalEnd",
+    value: function _onTraversalEnd(frameState) {
+      var id = frameState.viewport.id;
+
+      if (!this.frameStateData[id]) {
+        this.frameStateData[id] = {
+          selectedTiles: [],
+          _requestedTiles: [],
+          _emptyTiles: []
+        };
+      }
 
-    const set1 = new Set(oldSelectedTiles.map(t => t.id));
-    const set2 = new Set(selectedTiles.map(t => t.id));
-    let changed = oldSelectedTiles.filter(x => !set2.has(x.id)).length > 0;
-    changed = changed || selectedTiles.filter(x => !set1.has(x.id)).length > 0;
-    return changed;
-  }
+      var currentFrameStateData = this.frameStateData[id];
+      var selectedTiles = Object.values(this._traverser.selectedTiles);
+      currentFrameStateData.selectedTiles = selectedTiles;
+      currentFrameStateData._requestedTiles = Object.values(this._traverser.requestedTiles);
+      currentFrameStateData._emptyTiles = Object.values(this._traverser.emptyTiles);
+      this.traverseCounter--;
 
-  _loadTiles() {
-    for (const tile of this._requestedTiles) {
-      if (tile.contentUnloaded) {
-        this._loadTile(tile);
+      if (this.traverseCounter > 0) {
+        return;
       }
+
+      this._updateTiles();
     }
-  }
+  }, {
+    key: "_updateTiles",
+    value: function _updateTiles() {
+      this.selectedTiles = [];
+      this._requestedTiles = [];
+      this._emptyTiles = [];
 
-  _unloadTiles() {
-    this._cache.unloadTiles(this, (tileset, tile) => tileset._unloadTile(tile));
-  }
+      for (var frameStateKey in this.frameStateData) {
+        var frameStateDataValue = this.frameStateData[frameStateKey];
+        this.selectedTiles = this.selectedTiles.concat(frameStateDataValue.selectedTiles);
+        this._requestedTiles = this._requestedTiles.concat(frameStateDataValue._requestedTiles);
+        this._emptyTiles = this._emptyTiles.concat(frameStateDataValue._emptyTiles);
+      }
 
-  _updateStats() {
-    let tilesRenderable = 0;
-    let pointsRenderable = 0;
+      this.selectedTiles = this.options.onTraversalComplete(this.selectedTiles);
 
-    for (const tile of this.selectedTiles) {
-      if (tile.contentAvailable && tile.content) {
-        tilesRenderable++;
+      var _iterator3 = _createForOfIteratorHelper(this.selectedTiles),
+          _step3;
 
-        if (tile.content.pointCount) {
-          pointsRenderable += tile.content.pointCount;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _tile = _step3.value;
+          this._tiles[_tile.id] = _tile;
         }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
       }
-    }
 
-    this.stats.get(TILES_IN_VIEW).count = this.selectedTiles.length;
-    this.stats.get(TILES_RENDERABLE).count = tilesRenderable;
-    this.stats.get(POINTS_COUNT).count = pointsRenderable;
-  }
+      this._loadTiles();
 
-  _initializeTileSet(tilesetJson) {
-    this.root = this._initializeTileHeaders(tilesetJson, null);
+      this._unloadTiles();
 
-    if (this.type === _constants.TILESET_TYPE.TILES3D) {
-      this._initializeCesiumTileset(tilesetJson);
+      this._updateStats();
     }
+  }, {
+    key: "_tilesChanged",
+    value: function _tilesChanged(oldSelectedTiles, selectedTiles) {
+      if (oldSelectedTiles.length !== selectedTiles.length) {
+        return true;
+      }
 
-    if (this.type === _constants.TILESET_TYPE.I3S) {
-      this._initializeI3STileset();
+      var set1 = new Set(oldSelectedTiles.map(function (t) {
+        return t.id;
+      }));
+      var set2 = new Set(selectedTiles.map(function (t) {
+        return t.id;
+      }));
+      var changed = oldSelectedTiles.filter(function (x) {
+        return !set2.has(x.id);
+      }).length > 0;
+      changed = changed || selectedTiles.filter(function (x) {
+        return !set1.has(x.id);
+      }).length > 0;
+      return changed;
+    }
+  }, {
+    key: "_loadTiles",
+    value: function _loadTiles() {
+      var _iterator4 = _createForOfIteratorHelper(this._requestedTiles),
+          _step4;
+
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var _tile2 = _step4.value;
+
+          if (_tile2.contentUnloaded) {
+            this._loadTile(_tile2);
+          }
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
     }
+  }, {
+    key: "_unloadTiles",
+    value: function _unloadTiles() {
+      this._cache.unloadTiles(this, function (tileset, tile) {
+        return tileset._unloadTile(tile);
+      });
+    }
+  }, {
+    key: "_updateStats",
+    value: function _updateStats() {
+      var tilesRenderable = 0;
+      var pointsRenderable = 0;
+
+      var _iterator5 = _createForOfIteratorHelper(this.selectedTiles),
+          _step5;
+
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var _tile3 = _step5.value;
+
+          if (_tile3.contentAvailable && _tile3.content) {
+            tilesRenderable++;
+
+            if (_tile3.content.pointCount) {
+              pointsRenderable += _tile3.content.pointCount;
+            }
+          }
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
 
-    this._calculateViewProps();
-  }
-
-  _calculateViewProps() {
-    const root = this.root;
-    (0, _loaderUtils.assert)(root);
-    const {
-      center
-    } = root.boundingVolume;
-
-    if (!center) {
-      console.warn('center was not pre-calculated for the root tile');
-      this.cartographicCenter = new _core.Vector3();
-      this.zoom = 1;
-      return;
+      this.stats.get(TILES_IN_VIEW).count = this.selectedTiles.length;
+      this.stats.get(TILES_RENDERABLE).count = tilesRenderable;
+      this.stats.get(POINTS_COUNT).count = pointsRenderable;
     }
+  }, {
+    key: "_initializeTileSet",
+    value: function _initializeTileSet(tilesetJson) {
+      this.root = this._initializeTileHeaders(tilesetJson, null);
 
-    this.cartographicCenter = _geospatial.Ellipsoid.WGS84.cartesianToCartographic(center, new _core.Vector3());
-    this.cartesianCenter = center;
-    this.zoom = (0, _zoom.getZoomFromBoundingVolume)(root.boundingVolume);
-  }
-
-  _initializeStats() {
-    this.stats.get(TILES_TOTAL);
-    this.stats.get(TILES_LOADING);
-    this.stats.get(TILES_IN_MEMORY);
-    this.stats.get(TILES_IN_VIEW);
-    this.stats.get(TILES_RENDERABLE);
-    this.stats.get(TILES_LOADED);
-    this.stats.get(TILES_UNLOADED);
-    this.stats.get(TILES_LOAD_FAILED);
-    this.stats.get(POINTS_COUNT, 'memory');
-    this.stats.get(TILES_GPU_MEMORY, 'memory');
-  }
+      if (this.type === _constants.TILESET_TYPE.TILES3D) {
+        this._initializeCesiumTileset(tilesetJson);
+      }
 
-  _initializeTileHeaders(tilesetJson, parentTileHeader) {
-    const rootTile = new _tile3d.default(this, tilesetJson.root, parentTileHeader);
+      if (this.type === _constants.TILESET_TYPE.I3S) {
+        this._initializeI3STileset();
+      }
 
-    if (parentTileHeader) {
-      parentTileHeader.children.push(rootTile);
-      rootTile.depth = parentTileHeader.depth + 1;
+      this._calculateViewProps();
     }
+  }, {
+    key: "_calculateViewProps",
+    value: function _calculateViewProps() {
+      var root = this.root;
+      (0, _loaderUtils.assert)(root);
+      var center = root.boundingVolume.center;
 
-    if (this.type === _constants.TILESET_TYPE.TILES3D) {
-      const stack = [];
-      stack.push(rootTile);
-
-      while (stack.length > 0) {
-        const tile = stack.pop();
-        this.stats.get(TILES_TOTAL).incrementCount();
-        const children = tile.header.children || [];
-
-        for (const childHeader of children) {
-          const childTile = new _tile3d.default(this, childHeader, tile);
-          tile.children.push(childTile);
-          childTile.depth = tile.depth + 1;
-          stack.push(childTile);
-        }
+      if (!center) {
+        console.warn('center was not pre-calculated for the root tile');
+        this.cartographicCenter = new _core.Vector3();
+        this.zoom = 1;
+        return;
       }
-    }
 
-    return rootTile;
-  }
+      this.cartographicCenter = _geospatial.Ellipsoid.WGS84.cartesianToCartographic(center, new _core.Vector3());
+      this.cartesianCenter = center;
+      this.zoom = (0, _zoom.getZoomFromBoundingVolume)(root.boundingVolume);
+    }
+  }, {
+    key: "_initializeStats",
+    value: function _initializeStats() {
+      this.stats.get(TILES_TOTAL);
+      this.stats.get(TILES_LOADING);
+      this.stats.get(TILES_IN_MEMORY);
+      this.stats.get(TILES_IN_VIEW);
+      this.stats.get(TILES_RENDERABLE);
+      this.stats.get(TILES_LOADED);
+      this.stats.get(TILES_UNLOADED);
+      this.stats.get(TILES_LOAD_FAILED);
+      this.stats.get(POINTS_COUNT, 'memory');
+      this.stats.get(TILES_GPU_MEMORY, 'memory');
+    }
+  }, {
+    key: "_initializeTileHeaders",
+    value: function _initializeTileHeaders(tilesetJson, parentTileHeader) {
+      var rootTile = new _tile3d.default(this, tilesetJson.root, parentTileHeader);
+
+      if (parentTileHeader) {
+        parentTileHeader.children.push(rootTile);
+        rootTile.depth = parentTileHeader.depth + 1;
+      }
 
-  _initializeTraverser() {
-    let TraverserClass;
-    const type = this.type;
+      if (this.type === _constants.TILESET_TYPE.TILES3D) {
+        var stack = [];
+        stack.push(rootTile);
 
-    switch (type) {
-      case _constants.TILESET_TYPE.TILES3D:
-        TraverserClass = _tileset3dTraverser.default;
-        break;
+        while (stack.length > 0) {
+          var _tile4 = stack.pop();
 
-      case _constants.TILESET_TYPE.I3S:
-        TraverserClass = _i3sTilesetTraverser.default;
-        break;
+          this.stats.get(TILES_TOTAL).incrementCount();
+          var children = _tile4.header.children || [];
 
-      default:
-        TraverserClass = _tilesetTraverser.default;
-    }
+          var _iterator6 = _createForOfIteratorHelper(children),
+              _step6;
 
-    return new TraverserClass({
-      basePath: this.basePath,
-      onTraversalEnd: this._onTraversalEnd.bind(this)
-    });
-  }
+          try {
+            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+              var childHeader = _step6.value;
+              var childTile = new _tile3d.default(this, childHeader, _tile4);
 
-  _destroyTileHeaders(parentTile) {
-    this._destroySubtree(parentTile);
-  }
+              _tile4.children.push(childTile);
 
-  async _loadTile(tile) {
-    let loaded;
+              childTile.depth = _tile4.depth + 1;
+              stack.push(childTile);
+            }
+          } catch (err) {
+            _iterator6.e(err);
+          } finally {
+            _iterator6.f();
+          }
+        }
+      }
 
-    try {
-      this._onStartTileLoading();
+      return rootTile;
+    }
+  }, {
+    key: "_initializeTraverser",
+    value: function _initializeTraverser() {
+      var TraverserClass;
+      var type = this.type;
 
-      loaded = await tile.loadContent();
-    } catch (error) {
-      this._onTileLoadError(tile, error);
-    } finally {
-      this._onEndTileLoading();
+      switch (type) {
+        case _constants.TILESET_TYPE.TILES3D:
+          TraverserClass = _tileset3dTraverser.default;
+          break;
 
-      this._onTileLoad(tile, loaded);
-    }
-  }
+        case _constants.TILESET_TYPE.I3S:
+          TraverserClass = _i3sTilesetTraverser.default;
+          break;
 
-  _onTileLoadError(tile, error) {
-    this.stats.get(TILES_LOAD_FAILED).incrementCount();
-    const message = error.message || error.toString();
-    const url = tile.url;
-    console.error("A 3D tile failed to load: ".concat(tile.url, " ").concat(message));
-    this.options.onTileError(tile, message, url);
-  }
+        default:
+          TraverserClass = _tilesetTraverser.default;
+      }
 
-  _onTileLoad(tile, loaded) {
-    if (!loaded) {
-      return;
+      return new TraverserClass({
+        basePath: this.basePath,
+        onTraversalEnd: this._onTraversalEnd.bind(this)
+      });
     }
-
-    if (tile && tile.content) {
-      (0, _transformUtils.calculateTransformProps)(tile, tile.content);
+  }, {
+    key: "_destroyTileHeaders",
+    value: function _destroyTileHeaders(parentTile) {
+      this._destroySubtree(parentTile);
     }
+  }, {
+    key: "_loadTile",
+    value: function () {
+      var _loadTile2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(tile) {
+        var loaded;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.prev = 0;
 
-    this._addTileToCache(tile);
+                this._onStartTileLoading();
 
-    this.options.onTileLoad(tile);
-  }
+                _context.next = 4;
+                return tile.loadContent();
 
-  _onStartTileLoading() {
-    this._pendingCount++;
-    this.stats.get(TILES_LOADING).incrementCount();
-  }
+              case 4:
+                loaded = _context.sent;
+                _context.next = 10;
+                break;
 
-  _onEndTileLoading() {
-    this._pendingCount--;
-    this.stats.get(TILES_LOADING).decrementCount();
-  }
+              case 7:
+                _context.prev = 7;
+                _context.t0 = _context["catch"](0);
 
-  _addTileToCache(tile) {
-    this._cache.add(this, tile, tileset => tileset._updateCacheStats(tile));
-  }
+                this._onTileLoadError(tile, _context.t0);
 
-  _updateCacheStats(tile) {
-    this.stats.get(TILES_LOADED).incrementCount();
-    this.stats.get(TILES_IN_MEMORY).incrementCount();
-    this.gpuMemoryUsageInBytes += tile.content.byteLength || 0;
-    this.stats.get(TILES_GPU_MEMORY).count = this.gpuMemoryUsageInBytes;
-  }
+              case 10:
+                _context.prev = 10;
 
-  _unloadTile(tile) {
-    this.gpuMemoryUsageInBytes -= tile.content && tile.content.byteLength || 0;
-    this.stats.get(TILES_IN_MEMORY).decrementCount();
-    this.stats.get(TILES_UNLOADED).incrementCount();
-    this.stats.get(TILES_GPU_MEMORY).count = this.gpuMemoryUsageInBytes;
-    this.options.onTileUnload(tile);
-    tile.unloadContent();
-  }
+                this._onEndTileLoading();
 
-  _destroy() {
-    const stack = [];
+                this._onTileLoad(tile, loaded);
 
-    if (this.root) {
-      stack.push(this.root);
-    }
+                return _context.finish(10);
 
-    while (stack.length > 0) {
-      const tile = stack.pop();
+              case 14:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[0, 7, 10, 14]]);
+      }));
 
-      for (const child of tile.children) {
-        stack.push(child);
+      function _loadTile(_x) {
+        return _loadTile2.apply(this, arguments);
       }
 
-      this._destroyTile(tile);
-    }
+      return _loadTile;
+    }()
+  }, {
+    key: "_onTileLoadError",
+    value: function _onTileLoadError(tile, error) {
+      this.stats.get(TILES_LOAD_FAILED).incrementCount();
+      var message = error.message || error.toString();
+      var url = tile.url;
+      console.error("A 3D tile failed to load: ".concat(tile.url, " ").concat(message));
+      this.options.onTileError(tile, message, url);
+    }
+  }, {
+    key: "_onTileLoad",
+    value: function _onTileLoad(tile, loaded) {
+      if (!loaded) {
+        return;
+      }
 
-    this.root = null;
-  }
+      if (tile && tile.content) {
+        (0, _transformUtils.calculateTransformProps)(tile, tile.content);
+      }
 
-  _destroySubtree(tile) {
-    const root = tile;
-    const stack = [];
-    stack.push(root);
+      this._addTileToCache(tile);
+
+      this.options.onTileLoad(tile);
+    }
+  }, {
+    key: "_onStartTileLoading",
+    value: function _onStartTileLoading() {
+      this._pendingCount++;
+      this.stats.get(TILES_LOADING).incrementCount();
+    }
+  }, {
+    key: "_onEndTileLoading",
+    value: function _onEndTileLoading() {
+      this._pendingCount--;
+      this.stats.get(TILES_LOADING).decrementCount();
+    }
+  }, {
+    key: "_addTileToCache",
+    value: function _addTileToCache(tile) {
+      this._cache.add(this, tile, function (tileset) {
+        return tileset._updateCacheStats(tile);
+      });
+    }
+  }, {
+    key: "_updateCacheStats",
+    value: function _updateCacheStats(tile) {
+      this.stats.get(TILES_LOADED).incrementCount();
+      this.stats.get(TILES_IN_MEMORY).incrementCount();
+      this.gpuMemoryUsageInBytes += tile.content.byteLength || 0;
+      this.stats.get(TILES_GPU_MEMORY).count = this.gpuMemoryUsageInBytes;
+    }
+  }, {
+    key: "_unloadTile",
+    value: function _unloadTile(tile) {
+      this.gpuMemoryUsageInBytes -= tile.content && tile.content.byteLength || 0;
+      this.stats.get(TILES_IN_MEMORY).decrementCount();
+      this.stats.get(TILES_UNLOADED).incrementCount();
+      this.stats.get(TILES_GPU_MEMORY).count = this.gpuMemoryUsageInBytes;
+      this.options.onTileUnload(tile);
+      tile.unloadContent();
+    }
+  }, {
+    key: "_destroy",
+    value: function _destroy() {
+      var stack = [];
+
+      if (this.root) {
+        stack.push(this.root);
+      }
 
-    while (stack.length > 0) {
-      tile = stack.pop();
+      while (stack.length > 0) {
+        var _tile5 = stack.pop();
+
+        var _iterator7 = _createForOfIteratorHelper(_tile5.children),
+            _step7;
+
+        try {
+          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+            var child = _step7.value;
+            stack.push(child);
+          }
+        } catch (err) {
+          _iterator7.e(err);
+        } finally {
+          _iterator7.f();
+        }
 
-      for (const child of tile.children) {
-        stack.push(child);
+        this._destroyTile(_tile5);
       }
 
-      if (tile !== root) {
-        this._destroyTile(tile);
-      }
+      this.root = null;
     }
+  }, {
+    key: "_destroySubtree",
+    value: function _destroySubtree(tile) {
+      var root = tile;
+      var stack = [];
+      stack.push(root);
 
-    root.children = [];
-  }
-
-  _destroyTile(tile) {
-    this._cache.unloadTile(this, tile);
+      while (stack.length > 0) {
+        tile = stack.pop();
+
+        var _iterator8 = _createForOfIteratorHelper(tile.children),
+            _step8;
+
+        try {
+          for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+            var child = _step8.value;
+            stack.push(child);
+          }
+        } catch (err) {
+          _iterator8.e(err);
+        } finally {
+          _iterator8.f();
+        }
 
-    this._unloadTile(tile);
+        if (tile !== root) {
+          this._destroyTile(tile);
+        }
+      }
 
-    tile.destroy();
-  }
+      root.children = [];
+    }
+  }, {
+    key: "_destroyTile",
+    value: function _destroyTile(tile) {
+      this._cache.unloadTile(this, tile);
 
-  _initializeCesiumTileset(tilesetJson) {
-    this.asset = tilesetJson.asset;
+      this._unloadTile(tile);
 
-    if (!this.asset) {
-      throw new Error('Tileset must have an asset property.');
+      tile.destroy();
     }
+  }, {
+    key: "_initializeCesiumTileset",
+    value: function _initializeCesiumTileset(tilesetJson) {
+      this.asset = tilesetJson.asset;
 
-    if (this.asset.version !== '0.0' && this.asset.version !== '1.0') {
-      throw new Error('The tileset must be 3D Tiles version 0.0 or 1.0.');
-    }
+      if (!this.asset) {
+        throw new Error('Tileset must have an asset property.');
+      }
 
-    if ('tilesetVersion' in this.asset) {
-      this._queryParams.v = this.asset.tilesetVersion;
-    }
+      if (this.asset.version !== '0.0' && this.asset.version !== '1.0') {
+        throw new Error('The tileset must be 3D Tiles version 0.0 or 1.0.');
+      }
 
-    this.credits = {
-      attributions: this.options.attributions || []
-    };
-    this.description = this.options.description || '';
-    this.properties = tilesetJson.properties;
-    this.geometricError = tilesetJson.geometricError;
-    this._extensionsUsed = tilesetJson.extensionsUsed;
-    this.extras = tilesetJson.extras;
-  }
+      if ('tilesetVersion' in this.asset) {
+        this._queryParams.v = this.asset.tilesetVersion;
+      }
 
-  _initializeI3STileset() {
-    if (this.loadOptions.i3s && 'token' in this.loadOptions.i3s) {
-      this._queryParams.token = this.loadOptions.i3s.token;
+      this.credits = {
+        attributions: this.options.attributions || []
+      };
+      this.description = this.options.description || '';
+      this.properties = tilesetJson.properties;
+      this.geometricError = tilesetJson.geometricError;
+      this._extensionsUsed = tilesetJson.extensionsUsed;
+      this.extras = tilesetJson.extras;
+    }
+  }, {
+    key: "_initializeI3STileset",
+    value: function _initializeI3STileset() {
+      if (this.loadOptions.i3s && 'token' in this.loadOptions.i3s) {
+        this._queryParams.token = this.loadOptions.i3s.token;
+      }
     }
-  }
-
-}
+  }]);
+  return Tileset3D;
+}();
 
 exports.default = Tileset3D;
 
 function getQueryParamString(queryParams) {
-  const queryParamStrings = [];
+  var queryParamStrings = [];
 
-  for (const key of Object.keys(queryParams)) {
-    queryParamStrings.push("".concat(key, "=").concat(queryParams[key]));
+  for (var _i = 0, _Object$keys = Object.keys(queryParams); _i < _Object$keys.length; _i++) {
+    var _key = _Object$keys[_i];
+    queryParamStrings.push("".concat(_key, "=").concat(queryParams[_key]));
   }
 
   switch (queryParamStrings.length) {