@deck.gl-community/geo-layers 9.2.8 → 9.3.0-beta.2

package/dist/tileset/index.cjs

@@ -0,0 +1,721 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/tileset/index.js
+var tileset_exports = {};
+__export(tileset_exports, {
+  STRATEGY_DEFAULT: () => STRATEGY_DEFAULT,
+  STRATEGY_NEVER: () => STRATEGY_NEVER,
+  STRATEGY_REPLACE: () => STRATEGY_REPLACE,
+  SharedTile2DHeader: () => SharedTile2DHeader,
+  SharedTileset2D: () => SharedTileset2D
+});
+module.exports = __toCommonJS(tileset_exports);
+
+// dist/tileset/tileset-2d.js
+var import_loader_utils = require("@loaders.gl/loader-utils");
+var import_stats = require("@probe.gl/stats");
+
+// dist/tileset/tile-2d-header.js
+var SharedTile2DHeader = class {
+  /** x/y/z tile coordinate. */
+  index;
+  /** Closest cached ancestor tile in the current tree. */
+  parent;
+  /** Cached child tiles beneath this tile. */
+  children;
+  /** Loaded tile payload. */
+  content;
+  /** Stable tile cache id. */
+  id;
+  /** Resolved zoom level for the tile. */
+  zoom;
+  /** Optional application data associated with the tile. */
+  userData;
+  /** Bounds represented as `[[minX, minY], [maxX, maxY]]` for loaders.gl compatibility. */
+  boundingBox;
+  /** Abort controller for the current request, if one exists. */
+  _abortController;
+  /** Promise tracking the in-flight tile load, if any. */
+  _loader;
+  /** Monotonic request id used to ignore stale responses. */
+  _loaderId;
+  /** Indicates whether the last request completed successfully. */
+  _isLoaded;
+  /** Indicates whether the current request was cancelled. */
+  _isCancelled;
+  /** Indicates whether the tile should be refreshed. */
+  _needsReload;
+  /** Structured bounds assigned when the tile is created. */
+  _bbox;
+  /** Creates a tile header for a specific tile index. */
+  constructor(index) {
+    this.index = index;
+    this.parent = null;
+    this.children = [];
+    this.content = null;
+    this._loader = void 0;
+    this._abortController = null;
+    this._loaderId = 0;
+    this._isLoaded = false;
+    this._isCancelled = false;
+    this._needsReload = false;
+  }
+  /** Structured bounds for the tile in the active coordinate system. */
+  get bbox() {
+    return this._bbox;
+  }
+  /** Initializes the tile bounds once during tile creation. */
+  set bbox(value) {
+    if (this._bbox)
+      return;
+    this._bbox = value;
+    if ("west" in value) {
+      this.boundingBox = [
+        [value.west, value.south],
+        [value.east, value.north]
+      ];
+    } else {
+      this.boundingBox = [
+        [value.left, value.top],
+        [value.right, value.bottom]
+      ];
+    }
+  }
+  /** Resolves to loaded content while a request is in flight, otherwise returns the cached content. */
+  get data() {
+    const loader = this._loader;
+    if (!this._isCancelled && loader !== void 0) {
+      return loader.then(() => this.data);
+    }
+    return this.content;
+  }
+  /** Indicates whether tile content is available and up to date. */
+  get isLoaded() {
+    return this._isLoaded && !this._needsReload;
+  }
+  /** Indicates whether a tile request is currently in flight. */
+  get isLoading() {
+    return Boolean(this._loader) && !this._isCancelled;
+  }
+  /** Indicates whether the tile should be requested again. */
+  get needsReload() {
+    return this._needsReload || this._isCancelled;
+  }
+  /** Estimated byte size of the cached payload. */
+  get byteLength() {
+    const result = this.content ? this.content.byteLength : 0;
+    return Number.isFinite(result) ? result : 0;
+  }
+  /** Internal request pipeline used by {@link loadData}. */
+  async _loadData({ getData, requestScheduler, onLoad, onError }) {
+    const completeLoad = (tileData2, error2, loaderId2) => {
+      if (loaderId2 !== this._loaderId) {
+        return;
+      }
+      this._loader = void 0;
+      this.content = tileData2;
+      if (this._isCancelled && !tileData2) {
+        this._isLoaded = false;
+        return;
+      }
+      this._isLoaded = true;
+      this._isCancelled = false;
+      if (error2) {
+        onError(error2, this);
+        return;
+      }
+      onLoad(this);
+    };
+    const { index, id, bbox, userData, zoom } = this;
+    const loaderId = this._loaderId;
+    this._abortController = new AbortController();
+    const { signal } = this._abortController;
+    const requestToken = await requestScheduler.scheduleRequest(this, () => 1);
+    if (!requestToken) {
+      this._isCancelled = true;
+      return;
+    }
+    if (this._isCancelled) {
+      requestToken.done();
+      return;
+    }
+    let tileData = null;
+    let error;
+    try {
+      tileData = await getData({ index, id, bbox, userData, zoom, signal });
+    } catch (err) {
+      error = err || true;
+    } finally {
+      requestToken.done();
+    }
+    completeLoad(tileData, error, loaderId);
+  }
+  /** Loads tile data through the shared scheduler. */
+  loadData(opts) {
+    this._isLoaded = false;
+    this._isCancelled = false;
+    this._needsReload = false;
+    this._loaderId++;
+    this._loader = this._loadData(opts);
+    return this._loader;
+  }
+  /** Marks the tile stale so it is refreshed on the next traversal. */
+  setNeedsReload() {
+    if (this.isLoading) {
+      this.abort();
+      this._loader = void 0;
+    }
+    this._needsReload = true;
+  }
+  /** Cancels an in-flight tile request. */
+  abort() {
+    var _a;
+    if (this.isLoaded) {
+      return;
+    }
+    this._isCancelled = true;
+    (_a = this._abortController) == null ? void 0 : _a.abort();
+  }
+};
+
+// dist/tileset/tileset-2d.js
+var STRATEGY_NEVER = "never";
+var STRATEGY_REPLACE = "no-overlap";
+var STRATEGY_DEFAULT = "best-available";
+var DEFAULT_TILESET2D_PROPS = {
+  adapter: null,
+  extent: null,
+  tileSize: 512,
+  maxZoom: null,
+  minZoom: null,
+  maxCacheSize: 100,
+  maxCacheByteSize: null,
+  refinementStrategy: "best-available",
+  zRange: null,
+  maxRequests: 6,
+  debounceTime: 0,
+  zoomOffset: 0,
+  onTileLoad: () => {
+  },
+  onTileUnload: () => {
+  },
+  onTileError: () => {
+  }
+};
+var SharedTileset2D = class {
+  /** Live counters describing shared tileset state. */
+  stats;
+  /** Effective runtime options after defaults and metadata overrides have been applied. */
+  opts;
+  /** Cached metadata returned by the backing TileSource, if any. */
+  sourceMetadata = null;
+  /** Scheduler shared across all tile requests for this tileset. */
+  _requestScheduler;
+  /** Shared tile cache keyed by tile id. */
+  _cache;
+  /** Tracks whether parent/child links need rebuilding. */
+  _dirty;
+  /** Cached tiles sorted by zoom for traversal and rendering. */
+  _tiles;
+  /** Running total of cached payload byte size. */
+  _cacheByteSize;
+  /** Cumulative number of tiles evicted from the shared cache. */
+  _unloadedTileCount;
+  /** Subscribers watching tileset lifecycle events. */
+  _listeners = /* @__PURE__ */ new Set();
+  /** Selected and visible tiles tracked per consumer. */
+  _consumers = /* @__PURE__ */ new Map();
+  /** Option names explicitly set by the caller. */
+  _explicitOptionKeys = /* @__PURE__ */ new Set();
+  /** Caller-provided options before metadata-derived overrides are applied. */
+  _baseOpts = {};
+  /** Derived overrides sourced from TileSource metadata. */
+  _sourceMetadataOverrides = {};
+  /** Resolved maximum zoom level used by traversal. */
+  _maxZoom;
+  /** Resolved minimum zoom level used by traversal. */
+  _minZoom;
+  /** Most recent traversal context used to derive tile metadata. */
+  _lastTileContext = null;
+  /** Creates a tileset from either `getTileData` or a loaders.gl `TileSource`. */
+  constructor(opts) {
+    this.stats = new import_stats.Stats({
+      id: "SharedTileset2D",
+      stats: [
+        { name: "Tiles In Cache" },
+        { name: "Cache Size" },
+        { name: "Visible Tiles" },
+        { name: "Selected Tiles" },
+        { name: "Loading Tiles" },
+        { name: "Unloaded Tiles" },
+        { name: "Consumers" }
+      ]
+    });
+    this.opts = {
+      ...DEFAULT_TILESET2D_PROPS,
+      ...opts,
+      getTileData: opts.getTileData || (() => null),
+      tileSource: opts.tileSource
+    };
+    this._requestScheduler = new import_loader_utils.RequestScheduler({
+      throttleRequests: this.opts.maxRequests > 0 || this.opts.debounceTime > 0,
+      maxRequests: this.opts.maxRequests,
+      debounceTime: this.opts.debounceTime
+    });
+    this._cache = /* @__PURE__ */ new Map();
+    this._tiles = [];
+    this._dirty = false;
+    this._cacheByteSize = 0;
+    this._unloadedTileCount = 0;
+    if (!this.opts.tileSource && !opts.getTileData) {
+      throw new Error("SharedTileset2D requires either `getTileData` or `tileSource`.");
+    }
+    this.setOptions(opts);
+    this._updateStats();
+    if (this.opts.tileSource) {
+      this._initializeTileSource(this.opts.tileSource).catch(() => {
+      });
+    }
+  }
+  /** Convenience factory for wrapping a loaders.gl `TileSource`. */
+  static fromTileSource(tileSource, opts = {}) {
+    return new SharedTileset2D({ ...opts, tileSource });
+  }
+  /** All tiles currently present in the shared cache. */
+  get tiles() {
+    return this._tiles;
+  }
+  /** Estimated byte size of all tile content currently retained in cache. */
+  get cacheByteSize() {
+    return this._cacheByteSize;
+  }
+  /** Union of tiles selected by all attached consumers. */
+  get selectedTiles() {
+    return Array.from(this._getSelectedTilesUnion());
+  }
+  /** Union of tiles contributing to the visible result across all consumers and views, including unloaded selected tiles. */
+  get visibleTiles() {
+    const union = this._getVisibleTilesUnion();
+    for (const tile of this._getSelectedTilesUnion()) {
+      union.add(tile);
+    }
+    return Array.from(union);
+  }
+  /** Tiles currently loading anywhere in the shared cache. */
+  get loadingTiles() {
+    return Array.from(this._cache.values()).filter((tile) => tile.isLoading);
+  }
+  /** Tiles retained in cache that do not currently have loaded content. */
+  get unloadedTiles() {
+    return Array.from(this._cache.values()).filter((tile) => !tile.isLoaded);
+  }
+  /** Maximum resolved zoom level after applying metadata and explicit options. */
+  get maxZoom() {
+    return this._maxZoom;
+  }
+  /** Minimum resolved zoom level after applying metadata and explicit options. */
+  get minZoom() {
+    return this._minZoom;
+  }
+  /** Active refinement strategy for placeholder handling. */
+  get refinementStrategy() {
+    return this.opts.refinementStrategy || STRATEGY_DEFAULT;
+  }
+  /** Adapter currently used for traversal and tile metadata. */
+  get adapter() {
+    return this.opts.adapter;
+  }
+  /** Subscribes to tileset lifecycle events. */
+  subscribe(listener) {
+    this._listeners.add(listener);
+    return () => this._listeners.delete(listener);
+  }
+  /** Registers a consumer so cache pruning can account for its selected tiles. */
+  attachConsumer(id) {
+    this._consumers.set(id, { selectedTiles: /* @__PURE__ */ new Set(), visibleTiles: /* @__PURE__ */ new Set() });
+    this._updateStats();
+  }
+  /** Unregisters a consumer and prunes unused requests and tiles. */
+  detachConsumer(id) {
+    this._consumers.delete(id);
+    this._pruneRequests();
+    this._resizeCache();
+    this._updateStats();
+  }
+  /** Updates tileset options and reapplies TileSource metadata overrides. */
+  setOptions(opts) {
+    this._rememberExplicitOptions(opts);
+    this._baseOpts = { ...this._baseOpts, ...opts };
+    this._applyResolvedOptions();
+  }
+  /** Aborts in-flight requests and clears the shared cache. */
+  finalize() {
+    for (const tile of this._cache.values()) {
+      if (tile.isLoading) {
+        tile.abort();
+      }
+    }
+    this._cache.clear();
+    this._tiles = [];
+    this._consumers.clear();
+    this._cacheByteSize = 0;
+    this._unloadedTileCount = 0;
+    this._updateStats();
+  }
+  /** Marks all retained tiles stale and drops unused cached tiles. */
+  reloadAll() {
+    const selectedTiles = this._getSelectedTilesUnion();
+    for (const id of this._cache.keys()) {
+      const tile = this._cache.get(id);
+      if (tile && !selectedTiles.has(tile)) {
+        this._cache.delete(id);
+      } else if (tile) {
+        tile.setNeedsReload();
+      }
+    }
+    this._cacheByteSize = this._getCacheByteSize();
+    this.prepareTiles();
+    this._updateStats();
+  }
+  /** Updates the selected and visible tile sets for one consumer. */
+  updateConsumer(id, selectedTiles, visibleTiles) {
+    this._consumers.set(id, {
+      selectedTiles: new Set(selectedTiles),
+      visibleTiles: new Set(visibleTiles)
+    });
+    this._pruneRequests();
+    this._resizeCache();
+    this._updateStats();
+  }
+  /** Rebuilds parent/child links if the cache changed since the last traversal. */
+  prepareTiles() {
+    if (this._dirty) {
+      this._rebuildTree();
+      this._syncTiles();
+      this._dirty = false;
+    }
+  }
+  /** Returns tile indices needed to cover a viewport. */
+  getTileIndices({ viewState, maxZoom, minZoom, zRange, modelMatrix, modelMatrixInverse }) {
+    const { adapter, tileSize, extent, zoomOffset } = this.opts;
+    if (!adapter) {
+      throw new Error("SharedTileset2D requires an adapter before tile traversal can be used.");
+    }
+    this._lastTileContext = { viewState, tileSize };
+    return adapter.getTileIndices({
+      viewState,
+      maxZoom,
+      minZoom,
+      zRange,
+      tileSize,
+      extent: normalizeBounds(extent),
+      modelMatrix,
+      modelMatrixInverse,
+      zoomOffset
+    });
+  }
+  /** Returns the stable cache id for a tile index. */
+  getTileId(index) {
+    return `${index.x}-${index.y}-${index.z}`;
+  }
+  /** Returns the zoom level represented by a tile index. */
+  getTileZoom(index) {
+    return index.z;
+  }
+  /** Returns derived metadata used to initialize a tile header. */
+  getTileMetadata(index) {
+    if (!this._lastTileContext) {
+      throw new Error("SharedTileset2D metadata requested before traversal context was set.");
+    }
+    if (!this.opts.adapter) {
+      throw new Error("SharedTileset2D requires an adapter before tile metadata can be derived.");
+    }
+    return { bbox: this.opts.adapter.getTileBoundingBox(this._lastTileContext, index) };
+  }
+  /** Returns the parent tile index in the quadtree. */
+  getParentIndex(index) {
+    return { x: Math.floor(index.x / 2), y: Math.floor(index.y / 2), z: index.z - 1 };
+  }
+  getTile(index, create) {
+    const id = this.getTileId(index);
+    let tile = this._cache.get(id);
+    let needsReload = false;
+    if (!tile && create) {
+      tile = new SharedTile2DHeader(index);
+      Object.assign(tile, this.getTileMetadata(tile.index));
+      Object.assign(tile, { id, zoom: this.getTileZoom(tile.index) });
+      needsReload = true;
+      this._cache.set(id, tile);
+      this._dirty = true;
+      this._updateStats();
+    } else if (tile && tile.needsReload) {
+      needsReload = true;
+    }
+    if (tile) {
+      this._touchTile(id, tile);
+    }
+    if (tile && needsReload) {
+      tile.loadData({
+        getData: this.opts.getTileData,
+        requestScheduler: this._requestScheduler,
+        onLoad: this._handleTileLoad.bind(this),
+        onError: this._handleTileError.bind(this)
+      }).catch(() => {
+      });
+      this._updateStats();
+    }
+    return tile;
+  }
+  /** Loads metadata from a TileSource and reapplies derived option overrides. */
+  async _initializeTileSource(tileSource) {
+    try {
+      this.sourceMetadata = await tileSource.getMetadata();
+      this._sourceMetadataOverrides = this._getMetadataOverrides(this.sourceMetadata);
+      this._applyResolvedOptions();
+      this._notifyUpdate();
+    } catch (error) {
+      const normalizedError = error instanceof Error ? error : new Error(`TileSource metadata error: ${String(error)}`);
+      this._notifyError(normalizedError);
+    }
+  }
+  /** Tracks which options were explicitly set by the caller. */
+  _rememberExplicitOptions(opts) {
+    for (const key of Object.keys(opts)) {
+      this._explicitOptionKeys.add(key);
+    }
+  }
+  /** Resolves defaults, metadata overrides, and caller options into runtime settings. */
+  _applyResolvedOptions() {
+    const resolvedOpts = {
+      ...DEFAULT_TILESET2D_PROPS,
+      ...this._sourceMetadataOverrides,
+      ...this._baseOpts
+    };
+    if (resolvedOpts.tileSource) {
+      const tileSource = resolvedOpts.tileSource;
+      resolvedOpts.getTileData = (loadProps) => tileSource.getTileData(loadProps);
+    }
+    this.opts = resolvedOpts;
+    this._maxZoom = typeof this.opts.maxZoom === "number" && Number.isFinite(this.opts.maxZoom) ? Math.floor(this.opts.maxZoom) : void 0;
+    this._minZoom = typeof this.opts.minZoom === "number" && Number.isFinite(this.opts.minZoom) ? Math.ceil(this.opts.minZoom) : void 0;
+  }
+  /** Maps TileSource metadata into supported tileset options. */
+  _getMetadataOverrides(metadata) {
+    if (!metadata) {
+      return {};
+    }
+    const overrides = {};
+    if (!this._explicitOptionKeys.has("minZoom") && Number.isFinite(metadata.minZoom)) {
+      overrides.minZoom = metadata.minZoom;
+    }
+    if (!this._explicitOptionKeys.has("maxZoom") && Number.isFinite(metadata.maxZoom)) {
+      overrides.maxZoom = metadata.maxZoom;
+    }
+    if (!this._explicitOptionKeys.has("extent") && metadata.boundingBox) {
+      overrides.extent = [
+        metadata.boundingBox[0][0],
+        metadata.boundingBox[0][1],
+        metadata.boundingBox[1][0],
+        metadata.boundingBox[1][1]
+      ];
+    }
+    return overrides;
+  }
+  /** Handles successful tile loads. */
+  _handleTileLoad(tile) {
+    var _a, _b, _c;
+    (_b = (_a = this.opts).onTileLoad) == null ? void 0 : _b.call(_a, tile);
+    this._cacheByteSize = this._getCacheByteSize();
+    this._resizeCache();
+    for (const listener of this._listeners) {
+      (_c = listener.onTileLoad) == null ? void 0 : _c.call(listener, tile);
+    }
+    this._updateStats();
+  }
+  /** Handles tile load failures. */
+  _handleTileError(error, tile) {
+    var _a, _b, _c;
+    (_b = (_a = this.opts).onTileError) == null ? void 0 : _b.call(_a, error, tile);
+    for (const listener of this._listeners) {
+      (_c = listener.onTileError) == null ? void 0 : _c.call(listener, error, tile);
+    }
+    this._updateStats();
+  }
+  /** Handles tile eviction from cache. */
+  _handleTileUnload(tile) {
+    var _a, _b, _c;
+    this._unloadedTileCount++;
+    (_b = (_a = this.opts).onTileUnload) == null ? void 0 : _b.call(_a, tile);
+    for (const listener of this._listeners) {
+      (_c = listener.onTileUnload) == null ? void 0 : _c.call(listener, tile);
+    }
+    this._updateStats();
+  }
+  /** Notifies listeners that metadata or effective options changed. */
+  _notifyUpdate() {
+    var _a;
+    for (const listener of this._listeners) {
+      (_a = listener.onUpdate) == null ? void 0 : _a.call(listener);
+    }
+  }
+  /** Notifies listeners about asynchronous metadata errors. */
+  _notifyError(error) {
+    var _a;
+    for (const listener of this._listeners) {
+      (_a = listener.onError) == null ? void 0 : _a.call(listener, error);
+    }
+  }
+  /** Recomputes absolute counter stats and notifies listeners. */
+  _updateStats() {
+    var _a;
+    this._setStatCount("Tiles In Cache", this._cache.size);
+    this._setStatCount("Cache Size", this.cacheByteSize);
+    this._setStatCount("Visible Tiles", this.visibleTiles.length);
+    this._setStatCount("Selected Tiles", this.selectedTiles.length);
+    this._setStatCount("Loading Tiles", this.loadingTiles.length);
+    this._setStatCount("Unloaded Tiles", this._unloadedTileCount);
+    this._setStatCount("Consumers", this._consumers.size);
+    for (const listener of this._listeners) {
+      (_a = listener.onStatsChange) == null ? void 0 : _a.call(listener, this.stats);
+    }
+  }
+  /** Writes an absolute count into a probe.gl stat. */
+  _setStatCount(name, value) {
+    this.stats.get(name).reset().addCount(value);
+  }
+  /** Returns the union of selected tiles across all consumers. */
+  _getSelectedTilesUnion() {
+    const union = /* @__PURE__ */ new Set();
+    for (const consumer of this._consumers.values()) {
+      for (const tile of consumer.selectedTiles) {
+        union.add(tile);
+      }
+    }
+    return union;
+  }
+  /** Returns the union of visible tiles across all consumers. */
+  _getVisibleTilesUnion() {
+    const union = /* @__PURE__ */ new Set();
+    for (const consumer of this._consumers.values()) {
+      for (const tile of consumer.visibleTiles) {
+        union.add(tile);
+      }
+    }
+    return union;
+  }
+  /** Moves a touched tile to the back of the cache map for LRU eviction ordering. */
+  _touchTile(id, tile) {
+    this._cache.delete(id);
+    this._cache.set(id, tile);
+  }
+  /** Computes the total byte size of all cached tile content. */
+  _getCacheByteSize() {
+    let byteLength = 0;
+    for (const tile of this._cache.values()) {
+      byteLength += tile.byteLength;
+    }
+    return byteLength;
+  }
+  /** Cancels low-priority requests when consumers no longer need them. */
+  _pruneRequests() {
+    const { maxRequests = 0 } = this.opts;
+    const selectedTiles = this._getSelectedTilesUnion();
+    const visibleTiles = this._getVisibleTilesUnion();
+    const abortCandidates = [];
+    let ongoingRequestCount = 0;
+    for (const tile of this._cache.values()) {
+      if (tile.isLoading) {
+        ongoingRequestCount++;
+        if (!selectedTiles.has(tile) && !visibleTiles.has(tile)) {
+          abortCandidates.push(tile);
+        }
+      }
+    }
+    while (maxRequests > 0 && ongoingRequestCount > maxRequests && abortCandidates.length > 0) {
+      const tile = abortCandidates.shift();
+      if (tile) {
+        tile.abort();
+      }
+      ongoingRequestCount--;
+    }
+  }
+  /** Rebuilds parent and child links for all cached tiles. */
+  _rebuildTree() {
+    for (const tile of this._cache.values()) {
+      tile.parent = null;
+      if (tile.children) {
+        tile.children.length = 0;
+      }
+    }
+    for (const tile of this._cache.values()) {
+      const parent = this._getNearestAncestor(tile);
+      tile.parent = parent;
+      if (parent == null ? void 0 : parent.children) {
+        parent.children.push(tile);
+      }
+    }
+  }
+  /** Updates the sorted tile list used by traversal and rendering. */
+  _syncTiles() {
+    this._tiles = Array.from(this._cache.values()).sort((t1, t2) => t1.zoom - t2.zoom);
+  }
+  /** Evicts unused cached tiles when configured cache limits are exceeded. */
+  _resizeCache() {
+    const maxCacheSize = this.opts.maxCacheSize ?? 100;
+    const maxCacheByteSize = this.opts.maxCacheByteSize ?? Infinity;
+    const visibleTiles = this._getVisibleTilesUnion();
+    const selectedTiles = this._getSelectedTilesUnion();
+    const overflown = this._cache.size > maxCacheSize || this._cacheByteSize > maxCacheByteSize;
+    if (overflown) {
+      for (const [id, tile] of this._cache) {
+        if (!visibleTiles.has(tile) && !selectedTiles.has(tile)) {
+          this._cache.delete(id);
+          this._cacheByteSize = this._getCacheByteSize();
+          this._handleTileUnload(tile);
+        }
+        if (this._cache.size <= maxCacheSize && this._cacheByteSize <= maxCacheByteSize) {
+          break;
+        }
+      }
+      this._dirty = true;
+    }
+    if (this._dirty) {
+      this._rebuildTree();
+      this._syncTiles();
+      this._dirty = false;
+    }
+  }
+  /** Finds the nearest cached ancestor tile for placeholder rendering. */
+  _getNearestAncestor(tile) {
+    const { _minZoom = 0 } = this;
+    let index = tile.index;
+    while (this.getTileZoom(index) > _minZoom) {
+      index = this.getParentIndex(index);
+      const parent = this.getTile(index);
+      if (parent) {
+        return parent;
+      }
+    }
+    return null;
+  }
+};
+function normalizeBounds(extent) {
+  return extent && extent.length === 4 ? extent : void 0;
+}
+//# sourceMappingURL=index.cjs.map