@deck.gl/geo-layers 8.6.4 → 8.6.8

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

@@ -5,7 +5,13 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.STRATEGY_DEFAULT = exports.STRATEGY_REPLACE = exports.STRATEGY_NEVER = void 0;
+exports.default = exports.STRATEGY_REPLACE = exports.STRATEGY_NEVER = exports.STRATEGY_DEFAULT = 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"));
 
@@ -15,30 +21,39 @@ var _loaderUtils = require("@loaders.gl/loader-utils");
 
 var _math = require("math.gl");
 
-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';
+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; }
+
+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';
 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;
 
-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();
       }
     };
 
@@ -53,339 +68,476 @@ class Tileset2D {
     this._viewport = null;
     this._selectedTiles = null;
     this._frameNumber = 0;
+    this._modelMatrix = new _math.Matrix4();
+    this._modelMatrixInverse = new _math.Matrix4();
     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;
+      });
     }
-
-    this._cache.clear();
-
-    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();
-      }
+  }, {
+    key: "needsReload",
+    get: function get() {
+      return this._selectedTiles.some(function (tile) {
+        return tile.needsReload;
+      });
     }
-  }
+  }, {
+    key: "setOptions",
+    value: function setOptions(opts) {
+      Object.assign(this.opts, opts);
 
-  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;
+      if (Number.isFinite(opts.maxZoom)) {
+        this._maxZoom = Math.floor(opts.maxZoom);
       }
 
-      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();
+      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();
+      }
 
-    const changed = this.updateTileStates();
+      this._cache.clear();
 
-    if (this._dirty) {
-      this._resizeCache();
+      this._tiles = [];
+      this._selectedTiles = null;
     }
-
-    if (changed) {
-      this._frameNumber++;
+  }, {
+    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 _math.Matrix4(modelMatrix);
+      var isModelMatrixNew = !modelMatrixAsMatrix4.equals(this._modelMatrix);
+
+      if (!viewport.equals(this._viewport) || isModelMatrixNew) {
+        if (isModelMatrixNew) {
+          this._modelMatrixInverse = modelMatrixAsMatrix4.clone().invert();
+          this._modelMatrix = modelMatrixAsMatrix4;
+        }
 
-    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
-    });
-  }
-
-  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;
-  }
-
-  updateTileStates() {
-    this._updateTileStates(this.selectedTiles);
-
-    const {
-      maxRequests
-    } = this.opts;
-    const abortCandidates = [];
-    let ongoingRequestCount = 0;
-    let changed = false;
+        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();
+        }
+      } else if (this.needsReload) {
+        this._selectedTiles = this._selectedTiles.map(function (tile) {
+          return _this2._getTile({
+            x: tile.x,
+            y: tile.y,
+            z: tile.z
+          });
+        });
+      }
 
-    for (const tile of this._cache.values()) {
-      const isVisible = Boolean(tile.state & TILE_STATE_VISIBLE);
+      var changed = this.updateTileStates();
 
-      if (tile.isVisible !== isVisible) {
-        changed = true;
-        tile.isVisible = isVisible;
+      if (this._dirty) {
+        this._resizeCache();
       }
 
-      tile.isSelected = tile.state === TILE_STATE_SELECTED;
-
-      if (tile.isLoading) {
-        ongoingRequestCount++;
+      if (changed) {
+        this._frameNumber++;
+      }
 
-        if (!tile.isSelected) {
-          abortCandidates.push(tile);
+      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
+      });
+    }
+  }, {
+    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() {
+      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) {
-        const tile = abortCandidates.shift();
-        tile.abort();
-        ongoingRequestCount--;
+      if (maxRequests > 0) {
+        while (ongoingRequestCount > maxRequests && abortCandidates.length > 0) {
+          var tile = abortCandidates.shift();
+          tile.abort();
+          ongoingRequestCount--;
+        }
       }
-    }
 
-    return changed;
-  }
-
-  _rebuildTree() {
-    const {
-      _cache
-    } = this;
-
-    for (const tile of _cache.values()) {
-      tile.parent = null;
-      tile.children.length = 0;
+      return changed;
     }
-
-    for (const tile of _cache.values()) {
-      const parent = this._getNearestAncestor(tile.x, tile.y, tile.z);
-
-      tile.parent = parent;
-
-      if (parent) {
-        parent.children.push(tile);
+  }, {
+    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();
       }
-    }
-  }
 
-  _updateTileStates(selectedTiles) {
-    const {
-      _cache
-    } = this;
-    const refinementStrategy = this.opts.refinementStrategy || STRATEGY_DEFAULT;
+      var _iterator5 = _createForOfIteratorHelper(_cache.values()),
+          _step5;
 
-    for (const tile of _cache.values()) {
-      tile.state = TILE_STATE_UNKNOWN;
-    }
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var _tile2 = _step5.value;
 
-    for (const tile of selectedTiles) {
-      tile.state = TILE_STATE_SELECTED;
-    }
+          var parent = this._getNearestAncestor(_tile2.x, _tile2.y, _tile2.z);
 
-    if (refinementStrategy === STRATEGY_NEVER) {
-      return;
-    }
+          _tile2.parent = parent;
 
-    for (const tile of selectedTiles) {
-      getPlaceholderInAncestors(tile, refinementStrategy);
-    }
-
-    for (const tile of selectedTiles) {
-      if (needsPlaceholder(tile)) {
-        getPlaceholderInChildren(tile);
+          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();
+      }
 
-  _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 _iterator7 = _createForOfIteratorHelper(selectedTiles),
+          _step7;
 
-    if (overflown) {
-      for (const [tileId, tile] of _cache) {
-        if (!tile.isVisible) {
-          this._cacheByteSize -= opts.maxCacheByteSize ? tile.byteLength : 0;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var _tile3 = _step7.value;
+          _tile3.state = TILE_STATE_SELECTED;
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
 
-          _cache.delete(tileId);
+      if (refinementStrategy === STRATEGY_NEVER) {
+        return;
+      }
 
-          this.opts.onTileUnload(tile);
-        }
+      var _iterator8 = _createForOfIteratorHelper(selectedTiles),
+          _step8;
 
-        if (_cache.size <= maxCacheSize && this._cacheByteSize <= maxCacheByteSize) {
-          break;
+      try {
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          var _tile4 = _step8.value;
+          getPlaceholderInAncestors(_tile4, refinementStrategy);
         }
+      } catch (err) {
+        _iterator8.e(err);
+      } finally {
+        _iterator8.f();
       }
 
-      this._rebuildTree();
+      var _iterator9 = _createForOfIteratorHelper(selectedTiles),
+          _step9;
 
-      this._dirty = true;
-    }
+      try {
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var _tile5 = _step9.value;
 
-    if (this._dirty) {
-      this._tiles = Array.from(this._cache.values()).sort((t1, t2) => t1.z - t2.z);
-      this._dirty = false;
+          if (needsPlaceholder(_tile5)) {
+            getPlaceholderInChildren(_tile5);
+          }
+        }
+      } catch (err) {
+        _iterator9.e(err);
+      } finally {
+        _iterator9.f();
+      }
     }
-  }
-
-  _getTile({
-    x,
-    y,
-    z
-  }, create) {
-    const tileId = "".concat(x, ",").concat(y, ",").concat(z);
-
-    let tile = this._cache.get(tileId);
-
-    let needsReload = false;
+  }, {
+    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();
+        }
 
-    if (!tile && create) {
-      tile = new _tile2dHeader.default({
-        x,
-        y,
-        z
-      });
-      Object.assign(tile, this.getTileMetadata(tile));
-      needsReload = true;
+        this._rebuildTree();
 
-      this._cache.set(tileId, tile);
+        this._dirty = true;
+      }
 
-      this._dirty = true;
-    } else if (tile && tile.needsReload) {
-      needsReload = true;
+      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;
+      }
 
-    if (needsReload) {
-      tile.loadData({
-        getData: this.opts.getTileData,
-        requestScheduler: this._requestScheduler,
-        onLoad: this.onTileLoad,
-        onError: this.opts.onTileError
-      });
-    }
+      if (needsReload) {
+        tile.loadData({
+          getData: this.opts.getTileData,
+          requestScheduler: this._requestScheduler,
+          onLoad: this.onTileLoad,
+          onError: this.opts.onTileError
+        });
+      }
 
-    return tile;
-  }
+      return tile;
+    }
+  }, {
+    key: "_getNearestAncestor",
+    value: function _getNearestAncestor(x, y, z) {
+      var _this$_minZoom = this._minZoom,
+          _minZoom = _this$_minZoom === void 0 ? 0 : _this$_minZoom;
 
-  _getNearestAncestor(x, y, z) {
-    const {
-      _minZoom = 0
-    } = this;
-    let index = {
-      x,
-      y,
-      z
-    };
+      var index = {
+        x: x,
+        y: y,
+        z: z
+      };
 
-    while (index.z > _minZoom) {
-      index = this.getParentIndex(index);
+      while (index.z > _minZoom) {
+        index = this.getParentIndex(index);
 
-      const parent = this._getTile(index);
+        var parent = this._getTile(index);
 
-      if (parent) {
-        return parent;
+        if (parent) {
+          return parent;
+        }
       }
-    }
-
-    return null;
-  }
 
-}
+      return null;
+    }
+  }]);
+  return Tileset2D;
+}();
 
 exports.default = Tileset2D;
 
 function needsPlaceholder(tile) {
-  let t = tile;
+  var t = tile;
 
   while (t) {
     if (t.state & TILE_STATE_VISIBLE === 0) {
@@ -403,8 +555,8 @@ function needsPlaceholder(tile) {
 }
 
 function getPlaceholderInAncestors(tile, refinementStrategy) {
-  let parent;
-  let state = TILE_STATE_PLACEHOLDER;
+  var parent;
+  var state = TILE_STATE_PLACEHOLDER;
 
   while (parent = tile.parent) {
     if (tile.isLoaded) {
@@ -421,12 +573,22 @@ function getPlaceholderInAncestors(tile, refinementStrategy) {
 }
 
 function getPlaceholderInChildren(tile) {
-  for (const child of tile.children) {
-    child.state = Math.max(child.state, TILE_STATE_PLACEHOLDER);
+  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);
 
-    if (!child.isLoaded) {
-      getPlaceholderInChildren(child);
+      if (!child.isLoaded) {
+        getPlaceholderInChildren(child);
+      }
     }
+  } catch (err) {
+    _iterator11.e(err);
+  } finally {
+    _iterator11.f();
   }
 }
 //# sourceMappingURL=tileset-2d.js.map