@deck.gl/geo-layers 8.6.0-beta.1 → 8.6.3

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

@@ -7,12 +7,6 @@ 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 _tile2dHeader = _interopRequireDefault(require("./tile-2d-header"));
 
 var _utils = require("./utils");
@@ -21,39 +15,30 @@ var _loaderUtils = require("@loaders.gl/loader-utils");
 
 var _math = require("math.gl");
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { 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 = o[Symbol.iterator](); }, 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; }
-
-var TILE_STATE_UNKNOWN = 0;
-var TILE_STATE_VISIBLE = 1;
-var TILE_STATE_PLACEHOLDER = 3;
-var TILE_STATE_HIDDEN = 4;
-var TILE_STATE_SELECTED = 5;
-var STRATEGY_NEVER = 'never';
+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';
 exports.STRATEGY_NEVER = STRATEGY_NEVER;
-var STRATEGY_REPLACE = 'no-overlap';
+const STRATEGY_REPLACE = 'no-overlap';
 exports.STRATEGY_REPLACE = STRATEGY_REPLACE;
-var STRATEGY_DEFAULT = 'best-available';
+const STRATEGY_DEFAULT = 'best-available';
 exports.STRATEGY_DEFAULT = STRATEGY_DEFAULT;
-var DEFAULT_CACHE_SCALE = 5;
-
-var Tileset2D = function () {
-  function Tileset2D(opts) {
-    var _this = this;
+const DEFAULT_CACHE_SCALE = 5;
 
-    (0, _classCallCheck2.default)(this, Tileset2D);
+class Tileset2D {
+  constructor(opts) {
     this.opts = opts;
 
-    this.onTileLoad = function (tile) {
-      _this.opts.onTileLoad(tile);
+    this.onTileLoad = 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();
       }
     };
 
@@ -71,456 +56,336 @@ var Tileset2D = function () {
     this.setOptions(opts);
   }
 
-  (0, _createClass2.default)(Tileset2D, [{
-    key: "setOptions",
-    value: function setOptions(opts) {
-      Object.assign(this.opts, opts);
+  get tiles() {
+    return this._tiles;
+  }
 
-      if (Number.isFinite(opts.maxZoom)) {
-        this._maxZoom = Math.floor(opts.maxZoom);
-      }
+  get selectedTiles() {
+    return this._selectedTiles;
+  }
 
-      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();
-      }
+  get isLoaded() {
+    return this._selectedTiles.every(tile => tile.isLoaded);
+  }
 
-      this._cache.clear();
+  setOptions(opts) {
+    Object.assign(this.opts, opts);
 
-      this._tiles = [];
-      this._selectedTiles = null;
+    if (Number.isFinite(opts.maxZoom)) {
+      this._maxZoom = Math.floor(opts.maxZoom);
     }
-  }, {
-    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();
-      }
+
+    if (Number.isFinite(opts.minZoom)) {
+      this._minZoom = Math.ceil(opts.minZoom);
     }
-  }, {
-    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 _math.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;
-        }
+  }
 
-        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();
-        }
+  finalize() {
+    for (const tile of this._cache.values()) {
+      if (tile.isLoading) {
+        tile.abort();
       }
+    }
 
-      var changed = this.updateTileStates();
+    this._cache.clear();
 
-      if (this._dirty) {
-        this._resizeCache();
+    this._tiles = [];
+    this._selectedTiles = null;
+  }
+
+  reloadAll() {
+    for (const tileId of this._cache.keys()) {
+      const tile = this._cache.get(tileId);
+
+      if (!this._selectedTiles.includes(tile)) {
+        this._cache.delete(tileId);
+      } else {
+        tile.setNeedsReload();
       }
+    }
+  }
 
-      if (changed) {
-        this._frameNumber++;
+  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;
       }
 
-      return 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
+      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));
+
+      if (this._dirty) {
+        this._rebuildTree();
+      }
     }
-  }, {
-    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)
-      };
+
+    const changed = this.updateTileStates();
+
+    if (this._dirty) {
+      this._resizeCache();
     }
-  }, {
-    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;
+
+    if (changed) {
+      this._frameNumber++;
     }
-  }, {
-    key: "updateTileStates",
-    value: function updateTileStates() {
-      this._updateTileStates(this.selectedTiles);
-
-      var maxRequests = this.opts.maxRequests;
-      var abortCandidates = [];
-      var ongoingRequestCount = 0;
-      var changed = false;
-
-      var _iterator3 = _createForOfIteratorHelper(this._cache.values()),
-          _step3;
-
-      try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var _tile = _step3.value;
-          var isVisible = Boolean(_tile.state & TILE_STATE_VISIBLE);
-
-          if (_tile.isVisible !== isVisible) {
-            changed = true;
-            _tile.isVisible = isVisible;
-          }
-
-          _tile.isSelected = _tile.state === TILE_STATE_SELECTED;
-
-          if (_tile.isLoading) {
-            ongoingRequestCount++;
-
-            if (!_tile.isSelected) {
-              abortCandidates.push(_tile);
-            }
-          }
-        }
-      } catch (err) {
-        _iterator3.e(err);
-      } finally {
-        _iterator3.f();
-      }
 
-      if (maxRequests > 0) {
-        while (ongoingRequestCount > maxRequests && abortCandidates.length > 0) {
-          var tile = abortCandidates.shift();
-          tile.abort();
-          ongoingRequestCount--;
-        }
-      }
+    return this._frameNumber;
+  }
 
-      return changed;
-    }
-  }, {
-    key: "_rebuildTree",
-    value: function _rebuildTree() {
-      var _cache = this._cache;
-
-      var _iterator4 = _createForOfIteratorHelper(_cache.values()),
-          _step4;
-
-      try {
-        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-          var tile = _step4.value;
-          tile.parent = null;
-          tile.children.length = 0;
-        }
-      } catch (err) {
-        _iterator4.e(err);
-      } finally {
-        _iterator4.f();
-      }
+  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 _iterator5 = _createForOfIteratorHelper(_cache.values()),
-          _step5;
+  getTileMetadata({
+    x,
+    y,
+    z
+  }) {
+    const {
+      tileSize
+    } = this.opts;
+    return {
+      bbox: (0, _utils.tileToBoundingBox)(this._viewport, x, y, z, tileSize)
+    };
+  }
 
-      try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var _tile2 = _step5.value;
+  getParentIndex(tileIndex) {
+    tileIndex.x = Math.floor(tileIndex.x / 2);
+    tileIndex.y = Math.floor(tileIndex.y / 2);
+    tileIndex.z -= 1;
+    return tileIndex;
+  }
 
-          var parent = this._getNearestAncestor(_tile2.x, _tile2.y, _tile2.z);
+  updateTileStates() {
+    this._updateTileStates(this.selectedTiles);
 
-          _tile2.parent = parent;
+    const {
+      maxRequests
+    } = this.opts;
+    const abortCandidates = [];
+    let ongoingRequestCount = 0;
+    let changed = false;
 
-          if (parent) {
-            parent.children.push(_tile2);
-          }
-        }
-      } catch (err) {
-        _iterator5.e(err);
-      } finally {
-        _iterator5.f();
-      }
-    }
-  }, {
-    key: "_updateTileStates",
-    value: function _updateTileStates(selectedTiles) {
-      var _cache = this._cache;
-      var refinementStrategy = this.opts.refinementStrategy || STRATEGY_DEFAULT;
-
-      var _iterator6 = _createForOfIteratorHelper(_cache.values()),
-          _step6;
-
-      try {
-        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-          var tile = _step6.value;
-          tile.state = TILE_STATE_UNKNOWN;
-        }
-      } catch (err) {
-        _iterator6.e(err);
-      } finally {
-        _iterator6.f();
+    for (const tile of this._cache.values()) {
+      const isVisible = Boolean(tile.state & TILE_STATE_VISIBLE);
+
+      if (tile.isVisible !== isVisible) {
+        changed = true;
+        tile.isVisible = isVisible;
       }
 
-      var _iterator7 = _createForOfIteratorHelper(selectedTiles),
-          _step7;
+      tile.isSelected = tile.state === TILE_STATE_SELECTED;
+
+      if (tile.isLoading) {
+        ongoingRequestCount++;
 
-      try {
-        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-          var _tile3 = _step7.value;
-          _tile3.state = TILE_STATE_SELECTED;
+        if (!tile.isSelected) {
+          abortCandidates.push(tile);
         }
-      } catch (err) {
-        _iterator7.e(err);
-      } finally {
-        _iterator7.f();
       }
+    }
 
-      if (refinementStrategy === STRATEGY_NEVER) {
-        return;
+    if (maxRequests > 0) {
+      while (ongoingRequestCount > maxRequests && abortCandidates.length > 0) {
+        const tile = abortCandidates.shift();
+        tile.abort();
+        ongoingRequestCount--;
       }
+    }
 
-      var _iterator8 = _createForOfIteratorHelper(selectedTiles),
-          _step8;
+    return changed;
+  }
 
-      try {
-        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-          var _tile4 = _step8.value;
-          getPlaceholderInAncestors(_tile4, refinementStrategy);
-        }
-      } catch (err) {
-        _iterator8.e(err);
-      } finally {
-        _iterator8.f();
-      }
+  _rebuildTree() {
+    const {
+      _cache
+    } = this;
 
-      var _iterator9 = _createForOfIteratorHelper(selectedTiles),
-          _step9;
+    for (const tile of _cache.values()) {
+      tile.parent = null;
+      tile.children.length = 0;
+    }
 
-      try {
-        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
-          var _tile5 = _step9.value;
+    for (const tile of _cache.values()) {
+      const parent = this._getNearestAncestor(tile.x, tile.y, tile.z);
 
-          if (needsPlaceholder(_tile5)) {
-            getPlaceholderInChildren(_tile5);
-          }
-        }
-      } catch (err) {
-        _iterator9.e(err);
-      } finally {
-        _iterator9.f();
+      tile.parent = parent;
+
+      if (parent) {
+        parent.children.push(tile);
       }
     }
-  }, {
-    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 _iterator10 = _createForOfIteratorHelper(_cache),
-            _step10;
-
-        try {
-          for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
-            var _step10$value = (0, _slicedToArray2.default)(_step10.value, 2),
-                tileId = _step10$value[0],
-                tile = _step10$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) {
-          _iterator10.e(err);
-        } finally {
-          _iterator10.f();
-        }
+  }
 
-        this._rebuildTree();
+  _updateTileStates(selectedTiles) {
+    const {
+      _cache
+    } = this;
+    const refinementStrategy = this.opts.refinementStrategy || STRATEGY_DEFAULT;
 
-        this._dirty = true;
-      }
+    for (const tile of _cache.values()) {
+      tile.state = TILE_STATE_UNKNOWN;
+    }
 
-      if (this._dirty) {
-        this._tiles = Array.from(this._cache.values()).sort(function (t1, t2) {
-          return t1.z - t2.z;
-        });
-        this._dirty = false;
-      }
+    for (const tile of selectedTiles) {
+      tile.state = TILE_STATE_SELECTED;
     }
-  }, {
-    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;
-      }
 
-      if (needsReload) {
-        tile.loadData({
-          getData: this.opts.getTileData,
-          requestScheduler: this._requestScheduler,
-          onLoad: this.onTileLoad,
-          onError: this.opts.onTileError
-        });
-      }
+    if (refinementStrategy === STRATEGY_NEVER) {
+      return;
+    }
 
-      return tile;
+    for (const tile of selectedTiles) {
+      getPlaceholderInAncestors(tile, refinementStrategy);
     }
-  }, {
-    key: "_getNearestAncestor",
-    value: function _getNearestAncestor(x, y, z) {
-      var _this$_minZoom = this._minZoom,
-          _minZoom = _this$_minZoom === void 0 ? 0 : _this$_minZoom;
 
-      var index = {
-        x: x,
-        y: y,
-        z: z
-      };
+    for (const tile of selectedTiles) {
+      if (needsPlaceholder(tile)) {
+        getPlaceholderInChildren(tile);
+      }
+    }
+  }
+
+  _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;
 
-      while (index.z > _minZoom) {
-        index = this.getParentIndex(index);
+    if (overflown) {
+      for (const [tileId, tile] of _cache) {
+        if (!tile.isVisible) {
+          this._cacheByteSize -= opts.maxCacheByteSize ? tile.byteLength : 0;
 
-        var parent = this._getTile(index);
+          _cache.delete(tileId);
 
-        if (parent) {
-          return parent;
+          this.opts.onTileUnload(tile);
+        }
+
+        if (_cache.size <= maxCacheSize && this._cacheByteSize <= maxCacheByteSize) {
+          break;
         }
       }
 
-      return null;
+      this._rebuildTree();
+
+      this._dirty = true;
     }
-  }, {
-    key: "tiles",
-    get: function get() {
-      return this._tiles;
+
+    if (this._dirty) {
+      this._tiles = Array.from(this._cache.values()).sort((t1, t2) => t1.z - t2.z);
+      this._dirty = false;
     }
-  }, {
-    key: "selectedTiles",
-    get: function get() {
-      return this._selectedTiles;
+  }
+
+  _getTile({
+    x,
+    y,
+    z
+  }, create) {
+    const tileId = "".concat(x, ",").concat(y, ",").concat(z);
+
+    let tile = this._cache.get(tileId);
+
+    let needsReload = false;
+
+    if (!tile && create) {
+      tile = new _tile2dHeader.default({
+        x,
+        y,
+        z
+      });
+      Object.assign(tile, this.getTileMetadata(tile));
+      needsReload = true;
+
+      this._cache.set(tileId, tile);
+
+      this._dirty = true;
+    } else if (tile && tile.needsReload) {
+      needsReload = true;
     }
-  }, {
-    key: "isLoaded",
-    get: function get() {
-      return this._selectedTiles.every(function (tile) {
-        return tile.isLoaded;
+
+    if (needsReload) {
+      tile.loadData({
+        getData: this.opts.getTileData,
+        requestScheduler: this._requestScheduler,
+        onLoad: this.onTileLoad,
+        onError: this.opts.onTileError
       });
     }
-  }]);
-  return Tileset2D;
-}();
+
+    return tile;
+  }
+
+  _getNearestAncestor(x, y, z) {
+    const {
+      _minZoom = 0
+    } = this;
+    let index = {
+      x,
+      y,
+      z
+    };
+
+    while (index.z > _minZoom) {
+      index = this.getParentIndex(index);
+
+      const parent = this._getTile(index);
+
+      if (parent) {
+        return parent;
+      }
+    }
+
+    return null;
+  }
+
+}
 
 exports.default = Tileset2D;
 
 function needsPlaceholder(tile) {
-  var t = tile;
+  let t = tile;
 
   while (t) {
     if (t.state & TILE_STATE_VISIBLE === 0) {
@@ -538,8 +403,8 @@ function needsPlaceholder(tile) {
 }
 
 function getPlaceholderInAncestors(tile, refinementStrategy) {
-  var parent;
-  var state = TILE_STATE_PLACEHOLDER;
+  let parent;
+  let state = TILE_STATE_PLACEHOLDER;
 
   while (parent = tile.parent) {
     if (tile.isLoaded) {
@@ -556,22 +421,12 @@ function getPlaceholderInAncestors(tile, refinementStrategy) {
 }
 
 function getPlaceholderInChildren(tile) {
-  var _iterator11 = _createForOfIteratorHelper(tile.children),
-      _step11;
-
-  try {
-    for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
-      var child = _step11.value;
-      child.state = Math.max(child.state, TILE_STATE_PLACEHOLDER);
+  for (const child of tile.children) {
+    child.state = Math.max(child.state, TILE_STATE_PLACEHOLDER);
 
-      if (!child.isLoaded) {
-        getPlaceholderInChildren(child);
-      }
+    if (!child.isLoaded) {
+      getPlaceholderInChildren(child);
     }
-  } catch (err) {
-    _iterator11.e(err);
-  } finally {
-    _iterator11.f();
   }
 }
 //# sourceMappingURL=tileset-2d.js.map