openlayers-prefetching 0.1.0

package/dist/PrefetchManager.esm.js

@@ -0,0 +1,711 @@
+import { listen, unlistenByKey } from 'ol/events.js';
+import MapEventType from 'ol/MapEventType.js';
+import { getUid } from 'ol/util.js';
+import TileState from 'ol/TileState.js';
+import { getForViewAndSize, buffer } from 'ol/extent.js';
+
+const PrefetchCategory = {
+    SPATIAL_ACTIVE: 'spatial',
+    BACKGROUND_LAYERS_VIEWPORT: 'bgViewport',
+    BACKGROUND_LAYERS_BUFFER: 'bgBuffer',
+    NEXT_NAV_ACTIVE: 'nextNavActive',
+    NEXT_NAV_BACKGROUND: 'nextNavBackground',
+};
+const DEFAULT_CATEGORY_PRIORITIES = {
+    [PrefetchCategory.SPATIAL_ACTIVE]: 1,
+    [PrefetchCategory.BACKGROUND_LAYERS_VIEWPORT]: 2,
+    [PrefetchCategory.BACKGROUND_LAYERS_BUFFER]: 3,
+    [PrefetchCategory.NEXT_NAV_ACTIVE]: 4,
+    [PrefetchCategory.NEXT_NAV_BACKGROUND]: 5,
+};
+function getCategoryName(category) {
+    switch (category) {
+        case PrefetchCategory.SPATIAL_ACTIVE:
+            return 'Spatial (active)';
+        case PrefetchCategory.BACKGROUND_LAYERS_VIEWPORT:
+            return 'BG viewport';
+        case PrefetchCategory.BACKGROUND_LAYERS_BUFFER:
+            return 'BG buffer';
+        case PrefetchCategory.NEXT_NAV_ACTIVE:
+            return 'Next nav (active)';
+        case PrefetchCategory.NEXT_NAV_BACKGROUND:
+            return 'Next nav (BG)';
+        default:
+            return `Category ${category}`;
+    }
+}
+function createInitialCategoryCounts() {
+    return {
+        [PrefetchCategory.SPATIAL_ACTIVE]: { queued: 0, loading: 0, loaded: 0, errors: 0 },
+        [PrefetchCategory.BACKGROUND_LAYERS_VIEWPORT]: { queued: 0, loading: 0, loaded: 0, errors: 0 },
+        [PrefetchCategory.BACKGROUND_LAYERS_BUFFER]: { queued: 0, loading: 0, loaded: 0, errors: 0 },
+        [PrefetchCategory.NEXT_NAV_ACTIVE]: { queued: 0, loading: 0, loaded: 0, errors: 0 },
+        [PrefetchCategory.NEXT_NAV_BACKGROUND]: { queued: 0, loading: 0, loaded: 0, errors: 0 },
+    };
+}
+
+/**
+ * @module ol/prefetch/PrefetchStats
+ */
+/**
+ * Tracks prefetch statistics, per-category counts, error logs,
+ * and notifies listeners on changes.
+ */
+class PrefetchStats {
+    constructor() {
+        this.loadedCount_ = 0;
+        this.errorCount_ = 0;
+        this.categoryCounts_ = createInitialCategoryCounts();
+        this.errorLog_ = [];
+        this.listeners_ = [];
+    }
+    get categoryCounts() {
+        return this.categoryCounts_;
+    }
+    resetQueuedCounts() {
+        for (const key in this.categoryCounts_) {
+            this.categoryCounts_[key].queued = 0;
+            this.categoryCounts_[key].loading = 0;
+        }
+    }
+    recordQueued(category) {
+        if (this.categoryCounts_[category]) {
+            this.categoryCounts_[category].queued++;
+        }
+    }
+    setQueuedCount(category, queued) {
+        if (this.categoryCounts_[category]) {
+            this.categoryCounts_[category].queued = queued;
+        }
+    }
+    recordLoadingStart(category) {
+        if (this.categoryCounts_[category]) {
+            this.categoryCounts_[category].loading++;
+            this.categoryCounts_[category].queued = Math.max(0, this.categoryCounts_[category].queued - 1);
+        }
+    }
+    recordLoadingEnd(category) {
+        if (this.categoryCounts_[category]) {
+            this.categoryCounts_[category].loading = Math.max(0, this.categoryCounts_[category].loading - 1);
+        }
+    }
+    recordAlreadyLoaded(category) {
+        this.loadedCount_++;
+        if (this.categoryCounts_[category]) {
+            this.categoryCounts_[category].loaded++;
+            this.categoryCounts_[category].queued = Math.max(0, this.categoryCounts_[category].queued - 1);
+        }
+    }
+    recordLoaded(category) {
+        this.loadedCount_++;
+        if (this.categoryCounts_[category]) {
+            this.categoryCounts_[category].loaded++;
+        }
+    }
+    recordError(category, errorEntry) {
+        this.errorCount_++;
+        if (this.categoryCounts_[category]) {
+            this.categoryCounts_[category].errors++;
+        }
+        this.errorLog_.unshift(errorEntry);
+        if (this.errorLog_.length > 50) {
+            this.errorLog_.length = 50;
+        }
+    }
+    recordEmpty(category) {
+        if (this.categoryCounts_[category]) {
+            this.categoryCounts_[category].errors++;
+        }
+    }
+    getSnapshot(queueLength, loadingSize, paused, nextTarget, categoryPriorities) {
+        return {
+            queued: queueLength,
+            loading: loadingSize,
+            loaded: this.loadedCount_,
+            errors: this.errorCount_,
+            paused,
+            spatialActive: { ...this.categoryCounts_[PrefetchCategory.SPATIAL_ACTIVE] },
+            bgViewport: { ...this.categoryCounts_[PrefetchCategory.BACKGROUND_LAYERS_VIEWPORT] },
+            bgBuffer: { ...this.categoryCounts_[PrefetchCategory.BACKGROUND_LAYERS_BUFFER] },
+            nextNavActive: { ...this.categoryCounts_[PrefetchCategory.NEXT_NAV_ACTIVE] },
+            nextNavBackground: { ...this.categoryCounts_[PrefetchCategory.NEXT_NAV_BACKGROUND] },
+            nextTarget: nextTarget ? { center: nextTarget.center, zoom: nextTarget.zoom } : null,
+            recentErrors: this.errorLog_.slice(),
+            categoryPriorities: { ...categoryPriorities },
+        };
+    }
+    onStats(callback) {
+        this.listeners_.push(callback);
+    }
+    notify(stats) {
+        for (const cb of this.listeners_) {
+            cb(stats);
+        }
+    }
+    dispose() {
+        this.listeners_ = [];
+        this.errorLog_ = [];
+    }
+}
+
+/**
+ * @module ol/prefetch/PrefetchPlanner
+ */
+/**
+ * Responsible for deciding WHAT tiles to load.
+ *
+ * Builds the prioritised prefetch queue by inspecting the current view state,
+ * active layer, background layers, and next navigation target.
+ */
+class PrefetchPlanner {
+    /**
+     * @param spatialBufferFactor Factor to expand viewport for spatial prefetch.
+     */
+    constructor(spatialBufferFactor) {
+        this.lastNextTargetKey_ = null;
+        this.spatialBufferFactor_ = spatialBufferFactor;
+    }
+    buildQueue(map, activeLayer, backgroundLayers, nextTarget, categoryPriorities, stats) {
+        var _a, _b, _c;
+        const queue = [];
+        const seenTiles = new Set();
+        const nextTargetKey = nextTarget
+            ? `${nextTarget.center[0]}|${nextTarget.center[1]}|${nextTarget.zoom}`
+            : null;
+        const preserveNextCounts = nextTargetKey && nextTargetKey === this.lastNextTargetKey_;
+        const prevNextNavActive = preserveNextCounts
+            ? stats.categoryCounts[PrefetchCategory.NEXT_NAV_ACTIVE].queued
+            : 0;
+        const prevNextNavBackground = preserveNextCounts
+            ? stats.categoryCounts[PrefetchCategory.NEXT_NAV_BACKGROUND].queued
+            : 0;
+        stats.resetQueuedCounts();
+        const view = map.getView();
+        if (!view || !view.isDef()) {
+            return queue;
+        }
+        const mapSize = map.getSize();
+        if (!mapSize) {
+            return queue;
+        }
+        const viewState = view.getState();
+        const viewExtent = getForViewAndSize(viewState.center, viewState.resolution, viewState.rotation, mapSize);
+        const zoom = view.getZoom();
+        if (zoom === undefined) {
+            return queue;
+        }
+        const z = Math.round(zoom);
+        const projection = view.getProjection();
+        const pixelRatio = (_c = (_b = (_a = map).getPixelRatio) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : 1;
+        const ctx = { queue, seenTiles, pixelRatio, stats };
+        if (activeLayer) {
+            this.enqueueSpatialBuffer_(ctx, activeLayer, viewExtent, z, projection, categoryPriorities[PrefetchCategory.SPATIAL_ACTIVE], PrefetchCategory.SPATIAL_ACTIVE);
+        }
+        for (const entry of backgroundLayers) {
+            if (entry.layer === activeLayer) {
+                continue;
+            }
+            const subPriority = entry.priority * 0.001; // small factor to ensure background layers are ordered by their priority setting
+            this.enqueueViewportTiles_(ctx, entry.layer, viewExtent, z, projection, categoryPriorities[PrefetchCategory.BACKGROUND_LAYERS_VIEWPORT] + subPriority, PrefetchCategory.BACKGROUND_LAYERS_VIEWPORT);
+        }
+        if (nextTarget) {
+            this.lastNextTargetKey_ = nextTargetKey;
+            const nextZ = Math.round(nextTarget.zoom);
+            const nextResolution = view.getResolutionForZoom(nextTarget.zoom);
+            const nextExtent = getForViewAndSize(nextTarget.center, nextResolution, 0, mapSize);
+            if (activeLayer) {
+                this.enqueueViewportTiles_(ctx, activeLayer, nextExtent, nextZ, projection, categoryPriorities[PrefetchCategory.NEXT_NAV_ACTIVE], PrefetchCategory.NEXT_NAV_ACTIVE);
+                this.enqueueSpatialBuffer_(ctx, activeLayer, nextExtent, nextZ, projection, categoryPriorities[PrefetchCategory.NEXT_NAV_ACTIVE], PrefetchCategory.NEXT_NAV_ACTIVE);
+            }
+            for (const entry of backgroundLayers) {
+                if (entry.layer === activeLayer) {
+                    continue;
+                }
+                const subPriority = entry.priority * 0.001;
+                this.enqueueViewportTiles_(ctx, entry.layer, nextExtent, nextZ, projection, categoryPriorities[PrefetchCategory.NEXT_NAV_BACKGROUND] + subPriority, PrefetchCategory.NEXT_NAV_BACKGROUND);
+            }
+        }
+        if (!nextTarget) {
+            this.lastNextTargetKey_ = null;
+        }
+        else if (preserveNextCounts) {
+            if (stats.categoryCounts[PrefetchCategory.NEXT_NAV_ACTIVE].queued === 0) {
+                stats.setQueuedCount(PrefetchCategory.NEXT_NAV_ACTIVE, prevNextNavActive);
+            }
+            if (stats.categoryCounts[PrefetchCategory.NEXT_NAV_BACKGROUND].queued === 0) {
+                stats.setQueuedCount(PrefetchCategory.NEXT_NAV_BACKGROUND, prevNextNavBackground);
+            }
+        }
+        queue.sort((a, b) => a.priority - b.priority);
+        return queue;
+    }
+    enqueueViewportTiles_(ctx, layer, extent, z, projection, priority, category) {
+        const source = layer.getSource();
+        if (!source) {
+            return;
+        }
+        const tileGrid = source.getTileGridForProjection(projection);
+        const tileRange = tileGrid.getTileRangeForExtentAndZ(extent, z);
+        for (let x = tileRange.minX; x <= tileRange.maxX; x++) {
+            for (let y = tileRange.minY; y <= tileRange.maxY; y++) {
+                this.enqueueTile_(ctx, layer, source, [z, x, y], projection, priority, category);
+            }
+        }
+    }
+    enqueueSpatialBuffer_(ctx, layer, viewExtent, z, projection, priority, category) {
+        const source = layer.getSource();
+        if (!source) {
+            return;
+        }
+        const tileGrid = source.getTileGridForProjection(projection);
+        const extentWidth = viewExtent[2] - viewExtent[0];
+        const extentHeight = viewExtent[3] - viewExtent[1];
+        const bufferX = (extentWidth * (this.spatialBufferFactor_ - 1)) / 2;
+        const bufferY = (extentHeight * (this.spatialBufferFactor_ - 1)) / 2;
+        const bufferValue = Math.max(bufferX, bufferY);
+        const bufferedExtent = buffer(viewExtent, bufferValue);
+        const bufferedTileRange = tileGrid.getTileRangeForExtentAndZ(bufferedExtent, z);
+        const viewportTileRange = tileGrid.getTileRangeForExtentAndZ(viewExtent, z);
+        for (let x = bufferedTileRange.minX; x <= bufferedTileRange.maxX; x++) {
+            for (let y = bufferedTileRange.minY; y <= bufferedTileRange.maxY; y++) {
+                if (viewportTileRange.containsXY(x, y)) {
+                    continue;
+                }
+                this.enqueueTile_(ctx, layer, source, [z, x, y], projection, priority, category);
+            }
+        }
+    }
+    enqueueTile_(ctx, layer, source, tileCoord, projection, priority, category) {
+        const layerKey = getUid(layer);
+        const tileKey = `${layerKey}/${tileCoord[0]}/${tileCoord[1]}/${tileCoord[2]}`;
+        if (ctx.seenTiles.has(tileKey)) {
+            return;
+        }
+        ctx.seenTiles.add(tileKey);
+        let tile;
+        try {
+            tile = source.getTile(tileCoord[0], tileCoord[1], tileCoord[2], ctx.pixelRatio, projection);
+        }
+        catch {
+            return;
+        }
+        if (!tile) {
+            return;
+        }
+        const state = tile.getState();
+        if (state === TileState.LOADED || state === TileState.LOADING) {
+            return;
+        }
+        ctx.queue.push({
+            id: tileKey,
+            priority,
+            category,
+            layer,
+            tileCoord,
+            timestamp: Date.now(),
+        });
+        ctx.stats.recordQueued(category);
+    }
+}
+
+/**
+ * Responsible for WHEN to load.
+ *
+ * Manages the tick timer, checks preconditions (user interaction, map tile
+ * queue draining), and signals the manager to fill download slots.
+ */
+class PrefetchScheduler {
+    constructor(tickInterval, callbacks) {
+        this.tickTimer_ = null;
+        this.enabled_ = true;
+        this.tickInterval_ = tickInterval;
+        this.callbacks_ = callbacks;
+    }
+    set enabled(enabled) {
+        this.enabled_ = enabled;
+    }
+    get enabled() {
+        return this.enabled_;
+    }
+    scheduleTick() {
+        if (this.tickTimer_ || !this.enabled_) {
+            return;
+        }
+        this.tickTimer_ = setTimeout(() => {
+            this.tickTimer_ = null;
+            this.callbacks_.onRebuildNeeded();
+            this.callbacks_.onFillSlots();
+        }, this.tickInterval_);
+    }
+    runTick(userInteracting, mapTileQueue, stats) {
+        if (!this.enabled_ || userInteracting) {
+            return;
+        }
+        if (mapTileQueue && mapTileQueue.getTilesLoading() > 0) {
+            this.callbacks_.onStatsChanged();
+            this.scheduleTick();
+            return;
+        }
+        this.callbacks_.onRebuildNeeded();
+        this.callbacks_.onFillSlots();
+    }
+    dispose() {
+        if (this.tickTimer_) {
+            clearTimeout(this.tickTimer_);
+            this.tickTimer_ = null;
+        }
+    }
+}
+
+/**
+ * @module ol/prefetch/TileLoader
+ */
+/**
+ * Manages in-flight prefetch downloads. Supports abandoning all in-flight
+ * loads on user interaction so they don't block slots or compete with the
+ * map's own tile queue for HTTP connections.
+ */
+class TileLoader {
+    constructor(callbacks) {
+        this.loading_ = new Map();
+        this.callbacks_ = callbacks;
+    }
+    get activeCount() {
+        return this.loading_.size;
+    }
+    startTask(task, map, stats) {
+        var _a, _b, _c;
+        const source = task.layer.getSource();
+        if (!source) {
+            return;
+        }
+        const projection = map.getView().getProjection();
+        const pixelRatio = (_c = (_b = (_a = map).getPixelRatio) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : 1;
+        const category = task.category;
+        let tile;
+        try {
+            tile = source.getTile(task.tileCoord[0], task.tileCoord[1], task.tileCoord[2], pixelRatio, projection);
+        }
+        catch {
+            return;
+        }
+        if (!tile) {
+            return;
+        }
+        const state = tile.getState();
+        if (state === TileState.LOADED) {
+            stats.recordAlreadyLoaded(category);
+            return;
+        }
+        if (state === TileState.LOADING) {
+            return;
+        }
+        this.loading_.set(task.id, { task, unlisten: () => { } });
+        stats.recordLoadingStart(category);
+        const taskId = task.id;
+        const onTileChange = () => {
+            const newState = tile.getState();
+            if (newState !== TileState.LOADED &&
+                newState !== TileState.ERROR &&
+                newState !== TileState.EMPTY) {
+                return;
+            }
+            tile.removeEventListener('change', onTileChange);
+            if (!this.loading_.has(taskId)) {
+                return;
+            }
+            this.loading_.delete(taskId);
+            stats.recordLoadingEnd(category);
+            if (newState === TileState.LOADED) {
+                stats.recordLoaded(category);
+            }
+            else if (newState === TileState.ERROR) {
+                stats.recordError(category, this.buildErrorEntry_(task, tile));
+            }
+            else {
+                stats.recordEmpty(category);
+            }
+            this.callbacks_.onStatsChanged();
+            this.callbacks_.onSlotFreed();
+        };
+        this.loading_.set(taskId, {
+            task,
+            unlisten: () => tile.removeEventListener('change', onTileChange),
+        });
+        tile.addEventListener('change', onTileChange);
+        tile.load();
+    }
+    abandonAll(stats) {
+        for (const [, entry] of this.loading_) {
+            entry.unlisten();
+            stats.recordLoadingEnd(entry.task.category);
+        }
+        this.loading_.clear();
+    }
+    buildErrorEntry_(task, tile) {
+        const layerName = task.layer.get('name') || task.layer.get('label') || 'unknown';
+        const anyTile = tile;
+        let reason = anyTile._prefetchError;
+        if (!reason) {
+            const src = task.layer.getSource();
+            if (src && typeof src.getUrls === 'function') {
+                const urls = src.getUrls();
+                if (urls && urls.length > 0) {
+                    try {
+                        reason = `Tile load failed (${new URL(urls[0]).hostname})`;
+                    }
+                    catch {
+                        reason = 'Tile load failed';
+                    }
+                }
+            }
+            if (!reason) {
+                reason = 'Tile load failed';
+            }
+        }
+        return {
+            tileCoord: task.tileCoord,
+            category: getCategoryName(task.category),
+            layerName,
+            reason,
+            timestamp: Date.now(),
+        };
+    }
+    dispose() {
+        for (const [, entry] of this.loading_) {
+            entry.unlisten();
+        }
+        this.loading_.clear();
+    }
+}
+
+/**
+ * @module ol/prefetch/PrefetchManager
+ */
+/**
+ * Manages controlled prefetching of tiles across multiple layers and locations.
+ *
+ * Priority order:
+ * 1. User interactions (pan/zoom) always get absolute priority (managed by OL's TileQueue).
+ * 2. Spatial prefetching: tiles around the visible viewport for the active layer.
+ * 3. Background layer prefetching: load tiles for hidden layers at current viewport.
+ * 4. Anticipated navigation prefetching: preload tiles at the next expected location.
+ *
+ * When the user interacts with the map (pan/zoom), all prefetching is paused
+ * and only resumes after the user stops interacting.
+ */
+class PrefetchManager {
+    constructor(options) {
+        var _a, _b, _c, _d, _e;
+        this.userInteracting_ = false;
+        this.idleTimeout_ = null;
+        this.backgroundLayers_ = [];
+        this.activeLayer_ = null;
+        this.nextTarget_ = null;
+        this.categoryPriorities_ = {
+            ...DEFAULT_CATEGORY_PRIORITIES,
+        };
+        this.queue_ = [];
+        this.stats_ = new PrefetchStats();
+        this.listenerKeys_ = [];
+        this.map_ = options.map;
+        this.maxConcurrentPrefetches_ = (_a = options.maxConcurrentPrefetches) !== null && _a !== void 0 ? _a : 12;
+        this.idleDelay_ = (_b = options.idleDelay) !== null && _b !== void 0 ? _b : 300;
+        this.enabled_ = (_c = options.enabled) !== null && _c !== void 0 ? _c : true;
+        this.planner_ = new PrefetchPlanner((_d = options.spatialBufferFactor) !== null && _d !== void 0 ? _d : 1.5);
+        this.loader_ = new TileLoader({
+            onSlotFreed: () => {
+                if (!this.userInteracting_) {
+                    this.fillSlots_();
+                }
+            },
+            onStatsChanged: () => this.notifyStats_(),
+        });
+        this.scheduler_ = new PrefetchScheduler((_e = options.tickInterval) !== null && _e !== void 0 ? _e : 200, {
+            onRebuildNeeded: () => this.rebuildQueue_(),
+            onFillSlots: () => this.fillSlots_(),
+            onStatsChanged: () => this.notifyStats_(),
+        });
+        this.setupListeners_();
+    }
+    setupListeners_() {
+        const map = this.map_;
+        this.listenerKeys_.push(listen(map, MapEventType.MOVESTART, this.onMoveStart_, this), listen(map, MapEventType.MOVEEND, this.onMoveEnd_, this), listen(map, MapEventType.POSTRENDER, this.onPostRender_, this));
+    }
+    onMoveStart_() {
+        this.userInteracting_ = true;
+        if (this.idleTimeout_) {
+            clearTimeout(this.idleTimeout_);
+            this.idleTimeout_ = null;
+        }
+        this.loader_.abandonAll(this.stats_);
+        this.queue_ = this.queue_.filter((task) => task.category === PrefetchCategory.NEXT_NAV_ACTIVE ||
+            task.category === PrefetchCategory.NEXT_NAV_BACKGROUND);
+        this.stats_.resetQueuedCounts();
+        for (const task of this.queue_) {
+            this.stats_.recordQueued(task.category);
+        }
+        this.scheduler_.dispose();
+        this.notifyStats_();
+    }
+    onMoveEnd_() {
+        if (this.idleTimeout_) {
+            clearTimeout(this.idleTimeout_);
+        }
+        this.idleTimeout_ = setTimeout(() => {
+            this.userInteracting_ = false;
+            this.rebuildQueue_();
+            this.scheduler_.scheduleTick();
+            this.notifyStats_();
+        }, this.idleDelay_);
+    }
+    onPostRender_() {
+        if (!this.userInteracting_ && this.enabled_) {
+            this.scheduler_.scheduleTick();
+        }
+    }
+    rebuildQueue_() {
+        if (this.userInteracting_) {
+            return;
+        }
+        this.queue_ = this.planner_.buildQueue(this.map_, this.activeLayer_, this.backgroundLayers_, this.nextTarget_, this.categoryPriorities_, this.stats_);
+        this.notifyStats_();
+    }
+    fillSlots_() {
+        if (!this.enabled_ || this.userInteracting_) {
+            return;
+        }
+        if (this.queue_.length === 0 && this.loader_.activeCount === 0) {
+            this.notifyStats_();
+            return;
+        }
+        const mapTileQueue = this.getMapTileQueue_();
+        while (this.loader_.activeCount < this.maxConcurrentPrefetches_ &&
+            this.queue_.length > 0) {
+            if (this.userInteracting_) {
+                break;
+            }
+            if (mapTileQueue && mapTileQueue.getTilesLoading() > 0) {
+                this.scheduler_.scheduleTick();
+                break;
+            }
+            const task = this.queue_.shift();
+            if (!task) {
+                break;
+            }
+            this.loader_.startTask(task, this.map_, this.stats_);
+        }
+        if (this.queue_.length > 0 && this.loader_.activeCount === 0) {
+            this.scheduler_.scheduleTick();
+        }
+        this.notifyStats_();
+    }
+    getMapTileQueue_() {
+        var _a;
+        const mapAny = this.map_;
+        return (_a = mapAny.tileQueue_) !== null && _a !== void 0 ? _a : null;
+    }
+    notifyStats_() {
+        const snapshot = this.stats_.getSnapshot(this.queue_.length, this.loader_.activeCount, this.userInteracting_, this.nextTarget_, this.categoryPriorities_);
+        this.stats_.notify(snapshot);
+    }
+    addBackgroundLayer(layer, priority = 0) {
+        const exists = this.backgroundLayers_.some((e) => e.layer === layer);
+        if (!exists) {
+            this.backgroundLayers_.push({ layer, priority });
+            this.backgroundLayers_.sort((a, b) => a.priority - b.priority);
+            this.rebuildQueue_();
+            this.scheduler_.scheduleTick();
+        }
+    }
+    removeBackgroundLayer(layer) {
+        const idx = this.backgroundLayers_.findIndex((e) => e.layer === layer);
+        if (idx >= 0) {
+            this.backgroundLayers_.splice(idx, 1);
+            this.rebuildQueue_();
+        }
+    }
+    setBackgroundLayerPriority(layer, priority) {
+        const entry = this.backgroundLayers_.find((e) => e.layer === layer);
+        if (entry) {
+            entry.priority = priority;
+            this.backgroundLayers_.sort((a, b) => a.priority - b.priority);
+            this.rebuildQueue_();
+            this.scheduler_.scheduleTick();
+        }
+    }
+    getBackgroundLayers() {
+        return this.backgroundLayers_.map((e) => ({ layer: e.layer, priority: e.priority }));
+    }
+    setActiveLayer(layer) {
+        this.activeLayer_ = layer;
+        this.rebuildQueue_();
+        this.scheduler_.scheduleTick();
+    }
+    setNextTarget(center, zoom) {
+        this.nextTarget_ = { center, zoom };
+        this.rebuildQueue_();
+        this.scheduler_.scheduleTick();
+    }
+    clearNextTarget() {
+        this.nextTarget_ = null;
+    }
+    setEnabled(enabled) {
+        this.enabled_ = enabled;
+        this.scheduler_.enabled = enabled;
+        if (enabled) {
+            this.rebuildQueue_();
+            this.scheduler_.scheduleTick();
+        }
+        this.notifyStats_();
+    }
+    getEnabled() {
+        return this.enabled_;
+    }
+    setMaxConcurrent(max) {
+        this.maxConcurrentPrefetches_ = Math.max(1, max);
+        this.fillSlots_();
+    }
+    getMaxConcurrent() {
+        return this.maxConcurrentPrefetches_;
+    }
+    setCategoryPriorities(priorities) {
+        for (const key in priorities) {
+            const typedKey = key;
+            if (typedKey in this.categoryPriorities_ && priorities[typedKey] !== undefined) {
+                this.categoryPriorities_[typedKey] = priorities[typedKey];
+            }
+        }
+        this.rebuildQueue_();
+        this.scheduler_.scheduleTick();
+        this.notifyStats_();
+    }
+    getCategoryPriorities() {
+        return { ...this.categoryPriorities_ };
+    }
+    onStats(callback) {
+        this.stats_.onStats(callback);
+    }
+    getStats() {
+        return this.stats_.getSnapshot(this.queue_.length, this.loader_.activeCount, this.userInteracting_, this.nextTarget_, this.categoryPriorities_);
+    }
+    dispose() {
+        for (const key of this.listenerKeys_) {
+            unlistenByKey(key);
+        }
+        this.listenerKeys_.length = 0;
+        if (this.idleTimeout_) {
+            clearTimeout(this.idleTimeout_);
+        }
+        this.scheduler_.dispose();
+        this.loader_.dispose();
+        this.stats_.dispose();
+        this.queue_ = [];
+        this.backgroundLayers_ = [];
+        this.activeLayer_ = null;
+        this.nextTarget_ = null;
+    }
+}
+
+export { PrefetchCategory, PrefetchManager as default };
+//# sourceMappingURL=PrefetchManager.esm.js.map