@deck.gl/geo-layers 8.7.0-alpha.2 → 8.7.0-alpha.9

package/dist/es5/tile-layer/tileset-2d.js

@@ -7,38 +7,55 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = exports.STRATEGY_DEFAULT = exports.STRATEGY_REPLACE = exports.STRATEGY_NEVER = void 0;
 
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+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 _tile2dHeader = _interopRequireDefault(require("./tile-2d-header"));
 
 var _utils = require("./utils");
 
 var _loaderUtils = require("@loaders.gl/loader-utils");
 
-var _math = require("math.gl");
+var _core = require("@math.gl/core");
+
+var _STRATEGIES;
+
+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; }
 
-const TILE_STATE_UNKNOWN = 0;
-const TILE_STATE_VISIBLE = 1;
-const TILE_STATE_PLACEHOLDER = 3;
-const TILE_STATE_HIDDEN = 4;
-const TILE_STATE_SELECTED = 5;
-const STRATEGY_NEVER = 'never';
+var TILE_STATE_VISITED = 1;
+var TILE_STATE_VISIBLE = 2;
+var STRATEGY_NEVER = 'never';
 exports.STRATEGY_NEVER = STRATEGY_NEVER;
-const STRATEGY_REPLACE = 'no-overlap';
+var STRATEGY_REPLACE = 'no-overlap';
 exports.STRATEGY_REPLACE = STRATEGY_REPLACE;
-const STRATEGY_DEFAULT = 'best-available';
+var STRATEGY_DEFAULT = 'best-available';
 exports.STRATEGY_DEFAULT = STRATEGY_DEFAULT;
-const DEFAULT_CACHE_SCALE = 5;
+var DEFAULT_CACHE_SCALE = 5;
+var STRATEGIES = (_STRATEGIES = {}, (0, _defineProperty2.default)(_STRATEGIES, STRATEGY_DEFAULT, updateTileStateDefault), (0, _defineProperty2.default)(_STRATEGIES, STRATEGY_REPLACE, updateTileStateReplace), (0, _defineProperty2.default)(_STRATEGIES, STRATEGY_NEVER, function () {}), _STRATEGIES);
 
-class Tileset2D {
-  constructor(opts) {
+var Tileset2D = function () {
+  function Tileset2D(opts) {
+    var _this = this;
+
+    (0, _classCallCheck2.default)(this, Tileset2D);
     this.opts = opts;
 
-    this.onTileLoad = tile => {
-      this.opts.onTileLoad(tile);
+    this.onTileLoad = function (tile) {
+      _this.opts.onTileLoad(tile);
 
-      if (this.opts.maxCacheByteSize) {
-        this._cacheByteSize += tile.byteLength;
+      if (_this.opts.maxCacheByteSize) {
+        _this._cacheByteSize += tile.byteLength;
 
-        this._resizeCache();
+        _this._resizeCache();
       }
     };
 
@@ -56,377 +73,579 @@ class Tileset2D {
     this.setOptions(opts);
   }
 
-  get tiles() {
-    return this._tiles;
-  }
-
-  get selectedTiles() {
-    return this._selectedTiles;
-  }
-
-  get isLoaded() {
-    return this._selectedTiles.every(tile => tile.isLoaded);
-  }
-
-  setOptions(opts) {
-    Object.assign(this.opts, opts);
-
-    if (Number.isFinite(opts.maxZoom)) {
-      this._maxZoom = Math.floor(opts.maxZoom);
+  (0, _createClass2.default)(Tileset2D, [{
+    key: "tiles",
+    get: function get() {
+      return this._tiles;
     }
-
-    if (Number.isFinite(opts.minZoom)) {
-      this._minZoom = Math.ceil(opts.minZoom);
+  }, {
+    key: "selectedTiles",
+    get: function get() {
+      return this._selectedTiles;
     }
-  }
-
-  finalize() {
-    for (const tile of this._cache.values()) {
-      if (tile.isLoading) {
-        tile.abort();
-      }
+  }, {
+    key: "isLoaded",
+    get: function get() {
+      return this._selectedTiles.every(function (tile) {
+        return tile.isLoaded;
+      });
     }
+  }, {
+    key: "setOptions",
+    value: function setOptions(opts) {
+      Object.assign(this.opts, opts);
 
-    this._cache.clear();
+      if (Number.isFinite(opts.maxZoom)) {
+        this._maxZoom = Math.floor(opts.maxZoom);
+      }
 
-    this._tiles = [];
-    this._selectedTiles = null;
-  }
+      if (Number.isFinite(opts.minZoom)) {
+        this._minZoom = Math.ceil(opts.minZoom);
+      }
+    }
+  }, {
+    key: "finalize",
+    value: function finalize() {
+      var _iterator = _createForOfIteratorHelper(this._cache.values()),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var tile = _step.value;
+
+          if (tile.isLoading) {
+            tile.abort();
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
 
-  reloadAll() {
-    for (const tileId of this._cache.keys()) {
-      const tile = this._cache.get(tileId);
+      this._cache.clear();
 
-      if (!this._selectedTiles.includes(tile)) {
-        this._cache.delete(tileId);
-      } else {
-        tile.setNeedsReload();
+      this._tiles = [];
+      this._selectedTiles = null;
+    }
+  }, {
+    key: "reloadAll",
+    value: function reloadAll() {
+      var _iterator2 = _createForOfIteratorHelper(this._cache.keys()),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var tileId = _step2.value;
+
+          var tile = this._cache.get(tileId);
+
+          if (!this._selectedTiles.includes(tile)) {
+            this._cache.delete(tileId);
+          } else {
+            tile.setNeedsReload();
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
       }
     }
-  }
+  }, {
+    key: "update",
+    value: function update(viewport) {
+      var _this2 = this;
+
+      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+          zRange = _ref.zRange,
+          modelMatrix = _ref.modelMatrix;
+
+      var modelMatrixAsMatrix4 = new _core.Matrix4(modelMatrix);
+      var isModelMatrixNew = !modelMatrixAsMatrix4.equals(this._modelMatrix);
+
+      if (!viewport.equals(this._viewport) || isModelMatrixNew) {
+        if (isModelMatrixNew) {
+          this._modelMatrixInverse = modelMatrix && modelMatrixAsMatrix4.clone().invert();
+          this._modelMatrix = modelMatrix && modelMatrixAsMatrix4;
+        }
 
-  update(viewport, {
-    zRange,
-    modelMatrix
-  } = {}) {
-    const modelMatrixAsMatrix4 = new _math.Matrix4(modelMatrix);
-    const isModelMatrixNew = !modelMatrixAsMatrix4.equals(this._modelMatrix);
-
-    if (!viewport.equals(this._viewport) || isModelMatrixNew) {
-      if (isModelMatrixNew) {
-        this._modelMatrixInverse = modelMatrix && modelMatrixAsMatrix4.clone().invert();
-        this._modelMatrix = modelMatrix && modelMatrixAsMatrix4;
+        this._viewport = viewport;
+        var tileIndices = this.getTileIndices({
+          viewport: viewport,
+          maxZoom: this._maxZoom,
+          minZoom: this._minZoom,
+          zRange: zRange,
+          modelMatrix: this._modelMatrix,
+          modelMatrixInverse: this._modelMatrixInverse
+        });
+        this._selectedTiles = tileIndices.map(function (index) {
+          return _this2._getTile(index, true);
+        });
+
+        if (this._dirty) {
+          this._rebuildTree();
+        }
       }
 
-      this._viewport = viewport;
-      const tileIndices = this.getTileIndices({
-        viewport,
-        maxZoom: this._maxZoom,
-        minZoom: this._minZoom,
-        zRange,
-        modelMatrix: this._modelMatrix,
-        modelMatrixInverse: this._modelMatrixInverse
-      });
-      this._selectedTiles = tileIndices.map(index => this._getTile(index, true));
+      var changed = this.updateTileStates();
+
+      this._pruneRequests();
 
       if (this._dirty) {
-        this._rebuildTree();
+        this._resizeCache();
       }
-    }
 
-    const changed = this.updateTileStates();
+      if (changed) {
+        this._frameNumber++;
+      }
 
-    if (this._dirty) {
-      this._resizeCache();
+      return this._frameNumber;
     }
-
-    if (changed) {
-      this._frameNumber++;
+  }, {
+    key: "getTileIndices",
+    value: function getTileIndices(_ref2) {
+      var viewport = _ref2.viewport,
+          maxZoom = _ref2.maxZoom,
+          minZoom = _ref2.minZoom,
+          zRange = _ref2.zRange,
+          modelMatrix = _ref2.modelMatrix,
+          modelMatrixInverse = _ref2.modelMatrixInverse;
+      var _this$opts = this.opts,
+          tileSize = _this$opts.tileSize,
+          extent = _this$opts.extent,
+          zoomOffset = _this$opts.zoomOffset;
+      return (0, _utils.getTileIndices)({
+        viewport: viewport,
+        maxZoom: maxZoom,
+        minZoom: minZoom,
+        zRange: zRange,
+        tileSize: tileSize,
+        extent: extent,
+        modelMatrix: modelMatrix,
+        modelMatrixInverse: modelMatrixInverse,
+        zoomOffset: zoomOffset
+      });
     }
+  }, {
+    key: "getTileMetadata",
+    value: function getTileMetadata(_ref3) {
+      var x = _ref3.x,
+          y = _ref3.y,
+          z = _ref3.z;
+      var tileSize = this.opts.tileSize;
+      return {
+        bbox: (0, _utils.tileToBoundingBox)(this._viewport, x, y, z, tileSize)
+      };
+    }
+  }, {
+    key: "getParentIndex",
+    value: function getParentIndex(tileIndex) {
+      tileIndex.x = Math.floor(tileIndex.x / 2);
+      tileIndex.y = Math.floor(tileIndex.y / 2);
+      tileIndex.z -= 1;
+      return tileIndex;
+    }
+  }, {
+    key: "updateTileStates",
+    value: function updateTileStates() {
+      var refinementStrategy = this.opts.refinementStrategy || STRATEGY_DEFAULT;
+      var visibilities = new Array(this._cache.size);
+      var i = 0;
+
+      var _iterator3 = _createForOfIteratorHelper(this._cache.values()),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var tile = _step3.value;
+          visibilities[i++] = tile.isVisible;
+          tile.isSelected = false;
+          tile.isVisible = false;
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
 
-    return this._frameNumber;
-  }
-
-  getTileIndices({
-    viewport,
-    maxZoom,
-    minZoom,
-    zRange,
-    modelMatrix,
-    modelMatrixInverse
-  }) {
-    const {
-      tileSize,
-      extent,
-      zoomOffset
-    } = this.opts;
-    return (0, _utils.getTileIndices)({
-      viewport,
-      maxZoom,
-      minZoom,
-      zRange,
-      tileSize,
-      extent,
-      modelMatrix,
-      modelMatrixInverse,
-      zoomOffset
-    });
-  }
+      var _iterator4 = _createForOfIteratorHelper(this._selectedTiles),
+          _step4;
 
-  getTileMetadata({
-    x,
-    y,
-    z
-  }) {
-    const {
-      tileSize
-    } = this.opts;
-    return {
-      bbox: (0, _utils.tileToBoundingBox)(this._viewport, x, y, z, tileSize)
-    };
-  }
-
-  getParentIndex(tileIndex) {
-    tileIndex.x = Math.floor(tileIndex.x / 2);
-    tileIndex.y = Math.floor(tileIndex.y / 2);
-    tileIndex.z -= 1;
-    return tileIndex;
-  }
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var _tile = _step4.value;
+          _tile.isSelected = true;
+          _tile.isVisible = true;
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
 
-  updateTileStates() {
-    this._updateTileStates(this.selectedTiles);
+      (typeof refinementStrategy === 'function' ? refinementStrategy : STRATEGIES[refinementStrategy])(Array.from(this._cache.values()));
+      i = 0;
 
-    const {
-      maxRequests
-    } = this.opts;
-    const abortCandidates = [];
-    let ongoingRequestCount = 0;
-    let changed = false;
+      var _iterator5 = _createForOfIteratorHelper(this._cache.values()),
+          _step5;
 
-    for (const tile of this._cache.values()) {
-      const isVisible = Boolean(tile.state & TILE_STATE_VISIBLE);
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var _tile2 = _step5.value;
 
-      if (tile.isVisible !== isVisible) {
-        changed = true;
-        tile.isVisible = isVisible;
+          if (visibilities[i++] !== _tile2.isVisible) {
+            return true;
+          }
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
       }
 
-      tile.isSelected = tile.state === TILE_STATE_SELECTED;
-
-      if (tile.isLoading) {
-        ongoingRequestCount++;
-
-        if (!tile.isSelected) {
-          abortCandidates.push(tile);
+      return false;
+    }
+  }, {
+    key: "_pruneRequests",
+    value: function _pruneRequests() {
+      var maxRequests = this.opts.maxRequests;
+      var abortCandidates = [];
+      var ongoingRequestCount = 0;
+
+      var _iterator6 = _createForOfIteratorHelper(this._cache.values()),
+          _step6;
+
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var _tile3 = _step6.value;
+
+          if (_tile3.isLoading) {
+            ongoingRequestCount++;
+
+            if (!_tile3.isSelected && !_tile3.isVisible) {
+              abortCandidates.push(_tile3);
+            }
+          }
         }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
       }
-    }
 
-    if (maxRequests > 0) {
-      while (ongoingRequestCount > maxRequests && abortCandidates.length > 0) {
-        const tile = abortCandidates.shift();
+      while (maxRequests > 0 && ongoingRequestCount > maxRequests && abortCandidates.length > 0) {
+        var tile = abortCandidates.shift();
         tile.abort();
         ongoingRequestCount--;
       }
     }
+  }, {
+    key: "_rebuildTree",
+    value: function _rebuildTree() {
+      var _cache = this._cache;
+
+      var _iterator7 = _createForOfIteratorHelper(_cache.values()),
+          _step7;
+
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var tile = _step7.value;
+          tile.parent = null;
+          tile.children.length = 0;
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
 
-    return changed;
-  }
-
-  _rebuildTree() {
-    const {
-      _cache
-    } = this;
+      var _iterator8 = _createForOfIteratorHelper(_cache.values()),
+          _step8;
 
-    for (const tile of _cache.values()) {
-      tile.parent = null;
-      tile.children.length = 0;
-    }
+      try {
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          var _tile4 = _step8.value;
 
-    for (const tile of _cache.values()) {
-      const parent = this._getNearestAncestor(tile.x, tile.y, tile.z);
+          var parent = this._getNearestAncestor(_tile4.x, _tile4.y, _tile4.z);
 
-      tile.parent = parent;
+          _tile4.parent = parent;
 
-      if (parent) {
-        parent.children.push(tile);
+          if (parent) {
+            parent.children.push(_tile4);
+          }
+        }
+      } catch (err) {
+        _iterator8.e(err);
+      } finally {
+        _iterator8.f();
       }
     }
-  }
-
-  _updateTileStates(selectedTiles) {
-    const {
-      _cache
-    } = this;
-    const refinementStrategy = this.opts.refinementStrategy || STRATEGY_DEFAULT;
-
-    for (const tile of _cache.values()) {
-      tile.state = TILE_STATE_UNKNOWN;
-    }
+  }, {
+    key: "_resizeCache",
+    value: function _resizeCache() {
+      var _cache = this._cache,
+          opts = this.opts;
+      var maxCacheSize = opts.maxCacheSize || (opts.maxCacheByteSize ? Infinity : DEFAULT_CACHE_SCALE * this.selectedTiles.length);
+      var maxCacheByteSize = opts.maxCacheByteSize || Infinity;
+      var overflown = _cache.size > maxCacheSize || this._cacheByteSize > maxCacheByteSize;
+
+      if (overflown) {
+        var _iterator9 = _createForOfIteratorHelper(_cache),
+            _step9;
+
+        try {
+          for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+            var _step9$value = (0, _slicedToArray2.default)(_step9.value, 2),
+                tileId = _step9$value[0],
+                tile = _step9$value[1];
+
+            if (!tile.isVisible) {
+              this._cacheByteSize -= opts.maxCacheByteSize ? tile.byteLength : 0;
+
+              _cache.delete(tileId);
+
+              this.opts.onTileUnload(tile);
+            }
+
+            if (_cache.size <= maxCacheSize && this._cacheByteSize <= maxCacheByteSize) {
+              break;
+            }
+          }
+        } catch (err) {
+          _iterator9.e(err);
+        } finally {
+          _iterator9.f();
+        }
 
-    for (const tile of selectedTiles) {
-      tile.state = TILE_STATE_SELECTED;
-    }
+        this._rebuildTree();
 
-    if (refinementStrategy === STRATEGY_NEVER) {
-      return;
-    }
+        this._dirty = true;
+      }
 
-    for (const tile of selectedTiles) {
-      getPlaceholderInAncestors(tile, refinementStrategy);
+      if (this._dirty) {
+        this._tiles = Array.from(this._cache.values()).sort(function (t1, t2) {
+          return t1.z - t2.z;
+        });
+        this._dirty = false;
+      }
     }
+  }, {
+    key: "_getTile",
+    value: function _getTile(_ref4, create) {
+      var x = _ref4.x,
+          y = _ref4.y,
+          z = _ref4.z;
+      var tileId = "".concat(x, ",").concat(y, ",").concat(z);
+
+      var tile = this._cache.get(tileId);
+
+      var needsReload = false;
+
+      if (!tile && create) {
+        tile = new _tile2dHeader.default({
+          x: x,
+          y: y,
+          z: z
+        });
+        Object.assign(tile, this.getTileMetadata(tile));
+        needsReload = true;
+
+        this._cache.set(tileId, tile);
+
+        this._dirty = true;
+      } else if (tile && tile.needsReload) {
+        needsReload = true;
+      }
 
-    for (const tile of selectedTiles) {
-      if (needsPlaceholder(tile)) {
-        getPlaceholderInChildren(tile);
+      if (needsReload) {
+        tile.loadData({
+          getData: this.opts.getTileData,
+          requestScheduler: this._requestScheduler,
+          onLoad: this.onTileLoad,
+          onError: this.opts.onTileError
+        });
       }
+
+      return tile;
     }
-  }
+  }, {
+    key: "_getNearestAncestor",
+    value: function _getNearestAncestor(x, y, z) {
+      var _this$_minZoom = this._minZoom,
+          _minZoom = _this$_minZoom === void 0 ? 0 : _this$_minZoom;
 
-  _resizeCache() {
-    const {
-      _cache,
-      opts
-    } = this;
-    const maxCacheSize = opts.maxCacheSize || (opts.maxCacheByteSize ? Infinity : DEFAULT_CACHE_SCALE * this.selectedTiles.length);
-    const maxCacheByteSize = opts.maxCacheByteSize || Infinity;
-    const overflown = _cache.size > maxCacheSize || this._cacheByteSize > maxCacheByteSize;
+      var index = {
+        x: x,
+        y: y,
+        z: z
+      };
 
-    if (overflown) {
-      for (const [tileId, tile] of _cache) {
-        if (!tile.isVisible) {
-          this._cacheByteSize -= opts.maxCacheByteSize ? tile.byteLength : 0;
+      while (index.z > _minZoom) {
+        index = this.getParentIndex(index);
 
-          _cache.delete(tileId);
+        var parent = this._getTile(index);
 
-          this.opts.onTileUnload(tile);
-        }
-
-        if (_cache.size <= maxCacheSize && this._cacheByteSize <= maxCacheByteSize) {
-          break;
+        if (parent) {
+          return parent;
         }
       }
 
-      this._rebuildTree();
-
-      this._dirty = true;
+      return null;
     }
+  }]);
+  return Tileset2D;
+}();
+
+exports.default = Tileset2D;
 
-    if (this._dirty) {
-      this._tiles = Array.from(this._cache.values()).sort((t1, t2) => t1.z - t2.z);
-      this._dirty = false;
+function updateTileStateDefault(allTiles) {
+  var _iterator10 = _createForOfIteratorHelper(allTiles),
+      _step10;
+
+  try {
+    for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+      var tile = _step10.value;
+      tile.state = 0;
     }
+  } catch (err) {
+    _iterator10.e(err);
+  } finally {
+    _iterator10.f();
   }
 
-  _getTile({
-    x,
-    y,
-    z
-  }, create) {
-    const tileId = "".concat(x, ",").concat(y, ",").concat(z);
-
-    let tile = this._cache.get(tileId);
+  var _iterator11 = _createForOfIteratorHelper(allTiles),
+      _step11;
 
-    let needsReload = false;
+  try {
+    for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+      var _tile5 = _step11.value;
 
-    if (!tile && create) {
-      tile = new _tile2dHeader.default({
-        x,
-        y,
-        z
-      });
-      Object.assign(tile, this.getTileMetadata(tile));
-      needsReload = true;
+      if (_tile5.isSelected && !getPlaceholderInAncestors(_tile5)) {
+        getPlaceholderInChildren(_tile5);
+      }
+    }
+  } catch (err) {
+    _iterator11.e(err);
+  } finally {
+    _iterator11.f();
+  }
 
-      this._cache.set(tileId, tile);
+  var _iterator12 = _createForOfIteratorHelper(allTiles),
+      _step12;
 
-      this._dirty = true;
-    } else if (tile && tile.needsReload) {
-      needsReload = true;
+  try {
+    for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+      var _tile6 = _step12.value;
+      _tile6.isVisible = Boolean(_tile6.state & TILE_STATE_VISIBLE);
     }
+  } catch (err) {
+    _iterator12.e(err);
+  } finally {
+    _iterator12.f();
+  }
+}
 
-    if (needsReload) {
-      tile.loadData({
-        getData: this.opts.getTileData,
-        requestScheduler: this._requestScheduler,
-        onLoad: this.onTileLoad,
-        onError: this.opts.onTileError
-      });
-    }
+function updateTileStateReplace(allTiles) {
+  var _iterator13 = _createForOfIteratorHelper(allTiles),
+      _step13;
 
-    return tile;
+  try {
+    for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+      var tile = _step13.value;
+      tile.state = 0;
+    }
+  } catch (err) {
+    _iterator13.e(err);
+  } finally {
+    _iterator13.f();
   }
 
-  _getNearestAncestor(x, y, z) {
-    const {
-      _minZoom = 0
-    } = this;
-    let index = {
-      x,
-      y,
-      z
-    };
-
-    while (index.z > _minZoom) {
-      index = this.getParentIndex(index);
+  var _iterator14 = _createForOfIteratorHelper(allTiles),
+      _step14;
 
-      const parent = this._getTile(index);
+  try {
+    for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+      var _tile7 = _step14.value;
 
-      if (parent) {
-        return parent;
+      if (_tile7.isSelected) {
+        getPlaceholderInAncestors(_tile7);
       }
     }
-
-    return null;
+  } catch (err) {
+    _iterator14.e(err);
+  } finally {
+    _iterator14.f();
   }
 
+  var sortedTiles = Array.from(allTiles).sort(function (t1, t2) {
+    return t1.z - t2.z;
+  });
+
+  var _iterator15 = _createForOfIteratorHelper(sortedTiles),
+      _step15;
+
+  try {
+    for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
+      var _tile8 = _step15.value;
+      _tile8.isVisible = Boolean(_tile8.state & TILE_STATE_VISIBLE);
+
+      if (_tile8.isVisible || _tile8.state & TILE_STATE_VISITED) {
+        var _iterator16 = _createForOfIteratorHelper(_tile8.children),
+            _step16;
+
+        try {
+          for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+            var child = _step16.value;
+            child.state = TILE_STATE_VISITED;
+          }
+        } catch (err) {
+          _iterator16.e(err);
+        } finally {
+          _iterator16.f();
+        }
+      } else if (_tile8.isSelected) {
+        getPlaceholderInChildren(_tile8);
+      }
+    }
+  } catch (err) {
+    _iterator15.e(err);
+  } finally {
+    _iterator15.f();
+  }
 }
 
-exports.default = Tileset2D;
-
-function needsPlaceholder(tile) {
-  let t = tile;
-
-  while (t) {
-    if (t.state & TILE_STATE_VISIBLE === 0) {
+function getPlaceholderInAncestors(tile) {
+  while (tile) {
+    if (tile.isLoaded || tile.content) {
+      tile.state |= TILE_STATE_VISIBLE;
       return true;
     }
 
-    if (t.isLoaded) {
-      return false;
-    }
-
-    t = t.parent;
+    tile = tile.parent;
   }
 
-  return true;
+  return false;
 }
 
-function getPlaceholderInAncestors(tile, refinementStrategy) {
-  let parent;
-  let state = TILE_STATE_PLACEHOLDER;
+function getPlaceholderInChildren(tile) {
+  var _iterator17 = _createForOfIteratorHelper(tile.children),
+      _step17;
 
-  while (parent = tile.parent) {
-    if (tile.isLoaded) {
-      state = TILE_STATE_HIDDEN;
+  try {
+    for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
+      var child = _step17.value;
 
-      if (refinementStrategy === STRATEGY_DEFAULT) {
-        return;
+      if (child.isLoaded || child.content) {
+        child.state |= TILE_STATE_VISIBLE;
+      } else {
+        getPlaceholderInChildren(child);
       }
     }
-
-    parent.state = Math.max(parent.state, state);
-    tile = parent;
-  }
-}
-
-function getPlaceholderInChildren(tile) {
-  for (const child of tile.children) {
-    child.state = Math.max(child.state, TILE_STATE_PLACEHOLDER);
-
-    if (!child.isLoaded) {
-      getPlaceholderInChildren(child);
-    }
+  } catch (err) {
+    _iterator17.e(err);
+  } finally {
+    _iterator17.f();
   }
 }
 //# sourceMappingURL=tileset-2d.js.map