@gisatcz/deckgl-geolib 2.5.0-dev.4 → 2.5.0-dev.5

package/dist/esm/index.js

@@ -6718,11 +6718,37 @@ class CogTiles {
     bounds = [0, 0, 0, 0];
     geo = new GeoImage();
     options;
+    // Cache fetched rasters in an LRU-style Map keyed by `${z}/${x}/${y}/${fetchSize}`,
+    // with each value holding the cached raster for that tile request.
+    rasterCache = new Map();
+    maxCacheSize = 256;
+    // LRU cache helpers
+    getCachedRaster(key) {
+        const value = this.rasterCache.get(key);
+        if (value !== undefined) {
+            // Refresh order: delete and re-set
+            this.rasterCache.delete(key);
+            this.rasterCache.set(key, value);
+        }
+        return value;
+    }
+    setCachedRaster(key, value) {
+        this.rasterCache.set(key, value);
+        if (this.rasterCache.size > this.maxCacheSize) {
+            // Evict oldest
+            const oldestKey = this.rasterCache.keys().next().value;
+            if (typeof oldestKey === 'string') {
+                this.rasterCache.delete(oldestKey);
+            }
+        }
+    }
     // Cache GeoTIFFImage Promises by index to prevent redundant HTTP requests from geotiff 3.0.4+ eager loading
     // Stores Promises (not resolved values) so concurrent requests share the same getImage() call
     imageCache = new Map();
     // Store initialization promise to prevent concurrent duplicate initializations
     initializePromise;
+    // Track the last successfully initialized URL to detect URL changes
+    lastInitializedUrl;
     constructor(options) {
         this.options = { ...CogTilesGeoImageOptionsDefaults, ...options };
     }
@@ -6730,6 +6756,10 @@ class CogTiles {
         // Return existing initialization promise if already in progress (prevents concurrent duplicates)
         if (this.initializePromise)
             return this.initializePromise;
+        // Clear cache only if URL changed (preserves cache on idempotent re-init)
+        if (this.lastInitializedUrl !== url) {
+            this.rasterCache.clear();
+        }
         if (this.cog)
             return;
         this.initializePromise = (async () => {
@@ -6759,6 +6789,8 @@ class CogTiles {
                 }
                 this.zoomRange = this.calculateZoomRange(this.tileSize, image.getResolution()[0], await this.cog.getImageCount());
                 this.bounds = this.calculateBoundsAsLatLon(image.getBoundingBox());
+                // Mark initialization complete for this URL (used to detect URL changes)
+                this.lastInitializedUrl = url;
             }
             catch (error) {
                 // Reset initialization promise on error so retry can be attempted
@@ -6864,12 +6896,20 @@ class CogTiles {
             return this.cogZoomLookup.length - 1;
         // For zoom levels within the available range, find the exact or closest matching index.
         const exactMatchIndex = this.cogZoomLookup.indexOf(zoom);
-        if (exactMatchIndex === -1) {
-            // TO DO improve the condition if the match index is not found
-            /* eslint-disable no-console */
-            console.log('getImageIndexForZoomLevel: error in retrieving image by zoom index');
+        if (exactMatchIndex !== -1) {
+            return exactMatchIndex;
+        }
+        // No exact match: find the closest zoom level
+        let closestIndex = 0;
+        let minDistance = Math.abs(this.cogZoomLookup[0] - zoom);
+        for (let i = 1; i < this.cogZoomLookup.length; i += 1) {
+            const distance = Math.abs(this.cogZoomLookup[i] - zoom);
+            if (distance < minDistance) {
+                minDistance = distance;
+                closestIndex = i;
+            }
         }
-        return exactMatchIndex;
+        return closestIndex;
     }
     async getTileFromImage(tileX, tileY, zoom, fetchSize, signal) {
         // Create a fresh local AbortController for this specific fetch.
@@ -6883,6 +6923,12 @@ class CogTiles {
             signal.addEventListener('abort', () => controller.abort(), { once: true });
         }
         const localSignal = controller.signal;
+        // Check if raster is already cached
+        const cacheKey = `${zoom}/${tileX}/${tileY}/${fetchSize ?? this.tileSize}`;
+        const cachedRaster = this.getCachedRaster(cacheKey);
+        if (cachedRaster) {
+            return [cachedRaster];
+        }
         try {
             const imageIndex = this.getImageIndexForZoomLevel(zoom);
             // Cache Promises to share in-flight requests across concurrent tiles at the same overview
@@ -6973,8 +7019,7 @@ class CogTiles {
                                 tileBuffer[destRowOffset + destCol] = validRasterData[band][srcRowOffset + col];
                             }
                             else {
-                                /* eslint-disable no-console */
-                                console.log(`error in assigning data to tile buffer: destRow ${destRow}, destCol ${destCol}, FETCH_SIZE ${FETCH_SIZE}`);
+                                console.error(`[CogTiles] tile buffer bounds exceeded: destRow ${destRow}, destCol ${destCol}, FETCH_SIZE ${FETCH_SIZE}`);
                             }
                         }
                     }
@@ -6982,11 +7027,15 @@ class CogTiles {
                         validImageData[i * numChannels + band] = tileBuffer[i];
                     }
                 }
+                // Mark raster as cached after successful fetch
+                this.setCachedRaster(cacheKey, validImageData); // for partial overlap
                 return [validImageData];
             }
             // Case B: Perfect Match (Optimization)
             // If the read window is exactly 256x256 and aligned, we can read directly interleaved.
             const tileData = await targetImage.readRasters({ window, interleave: true, signal: localSignal });
+            // Mark raster as cached after successful fetch
+            this.setCachedRaster(cacheKey, tileData); // for perfect match
             return [tileData];
         }
         catch (error) {
@@ -7047,6 +7096,10 @@ class CogTiles {
             tileWidth = this.tileSize;
             tileHeight = this.tileSize;
         }
+        // Guard against abort race condition: if signal aborted after cache hit but before expensive geo.getMap()
+        if (signal?.aborted) {
+            return null;
+        }
         return this.geo.getMap({
             rasters,
             width: tileWidth,