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

package/dist/esm/index.js

@@ -7,6 +7,45 @@ import { getMeshBoundingBox } from '@loaders.gl/schema';
 import { concatenateTypedArrays } from '@loaders.gl/loader-utils';
 import { SimpleMeshLayer } from '@deck.gl/mesh-layers';
 
+let isListenerAttached = false;
+/**
+ * Suppresses unhandled AbortErrors from deck.gl tile cancellation.
+ *
+ * NOTE: The library's main entry point installs this handler automatically
+ * when the package is imported via its primary build (for example
+ * `import '@gisatcz/deckgl-geolib'`). This default prevents console spam during
+ * normal tile cancellation (pan/zoom) for the vast majority of consumers.
+ *
+ * If you need to control installation manually (for example when importing
+ * internals or for custom lifecycle control), import and call the exported
+ * function yourself:
+ *
+ *   import { suppressGlobalAbortErrors } from '@gisatcz/deckgl-geolib';
+ *   suppressGlobalAbortErrors();
+ *
+ * Warning: This suppresses ALL unhandled AbortErrors (including from your own
+ * code). If you need finer control, implement a custom `unhandledrejection`
+ * handler instead.
+ *
+ * The listener is attached only once and only in browser environments,
+ * making this function idempotent and safe to call multiple times.
+ */
+function suppressGlobalAbortErrors() {
+    // Ensure we are in a browser environment and haven't already attached the listener
+    if (typeof window !== 'undefined' && !isListenerAttached) {
+        window.addEventListener('unhandledrejection', (event) => {
+            // Suppress standard AbortErrors from tile cancellation and fetch aborts.
+            // These are expected during viewport changes and represent normal control flow,
+            // not application errors.
+            if (event.reason && event.reason.name === 'AbortError') {
+                // Prevent the browser from logging it to the console
+                event.preventDefault();
+            }
+        });
+        isListenerAttached = true;
+    }
+}
+
 /* eslint-disable no-restricted-globals, no-restricted-syntax */
 /* global SharedArrayBuffer */
 
@@ -2957,7 +2996,7 @@ class CustomAggregateError extends Error {
         this.name = 'AggregateError';
     }
 }
-const AggregateError = CustomAggregateError;
+const AggregateError$1 = CustomAggregateError;
 
 class Block {
     /**
@@ -3088,7 +3127,7 @@ class BlockedSource extends BaseSource {
         const blocks = allBlockIds.map((id) => this.blockCache.get(id) || this.evictedBlocks.get(id));
         const failedBlocks = blocks.filter((i) => !i);
         if (failedBlocks.length) {
-            throw new AggregateError(failedBlocks, 'Request failed');
+            throw new AggregateError$1(failedBlocks, 'Request failed');
         }
         // create a final Map, with all required blocks for this request to satisfy
         const requiredBlocks = new Map(zip(allBlockIds, blocks));
@@ -5547,14 +5586,14 @@ function addSkirt(attributes, triangles, skirtHeight, outsideIndices) {
  * @returns {number[][]} - outside edges data
  */
 function getOutsideEdgesFromTriangles(triangles) {
-    // Use integer keys instead of strings: min * 70000 + max is collision-free
-    // for any grid ≤ 257×257 (66,049 vertices < 70,000)
+    // Use BigInt keys to avoid collisions for large meshes.
+    // Pack min and max into a single BigInt key: (min << 32) | max
     const edgeMap = new Map();
     const processEdge = (a, b) => {
         const min = Math.min(a, b);
         const max = Math.max(a, b);
-        // Integer key: no string allocation per edge
-        const key = min * 70000 + max;
+        // Pack indices into a single BigInt key to avoid string allocation and collisions
+        const key = (BigInt(min) << 32n) | BigInt(max);
         if (edgeMap.has(key)) {
             edgeMap.delete(key); // Interior edge, remove
         }
@@ -6679,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 };
     }
@@ -6691,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 () => {
@@ -6720,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
@@ -6825,120 +6896,161 @@ 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');
-        }
-        return exactMatchIndex;
-    }
-    async getTileFromImage(tileX, tileY, zoom, fetchSize) {
-        const imageIndex = this.getImageIndexForZoomLevel(zoom);
-        // Cache Promises to share in-flight requests across concurrent tiles at the same overview
-        let imagePromise = this.imageCache.get(imageIndex);
-        if (!imagePromise) {
-            imagePromise = this.cog.getImage(imageIndex);
-            this.imageCache.set(imageIndex, imagePromise);
-        }
-        const targetImage = await imagePromise;
-        // --- STEP 1: CALCULATE BOUNDS IN METERS ---
-        // 2. Get COG Metadata (image = COG)
-        const imageResolution = this.cogResolutionLookup[imageIndex];
-        const imageHeight = targetImage.getHeight();
-        const imageWidth = targetImage.getWidth();
-        const [imgOriginX, imgOriginY] = this.cogOrigin;
-        // 3. Define Web Mercator Constants
-        // We use the class property tileSize (usually 256) as the ground truth for grid calculations
-        const TILE_SIZE = this.tileSize;
-        const ORIGIN_X = webMercatorOrigin[0];
-        const ORIGIN_Y = webMercatorOrigin[1];
-        // 4. Calculate Tile BBox in World Meters
-        // This defines where the map expects the tile to be physically located
-        const tileGridResolution = (EARTH_CIRCUMFERENCE / TILE_SIZE) / (2 ** zoom);
-        const tileMinXMeters = ORIGIN_X + (tileX * TILE_SIZE * tileGridResolution);
-        const tileMaxYMeters = ORIGIN_Y - (tileY * TILE_SIZE * tileGridResolution);
-        // Note: We don't strictly need MaxX/MinY meters for the start calculation,
-        // but they are useful if debugging the full meter footprint.
-        // --- STEP 2: CONVERT TO PIXEL COORDINATES ---
-        // 5. Calculate precise floating-point start position relative to the image
-        const windowMinX = (tileMinXMeters - imgOriginX) / imageResolution;
-        const windowMinY = (imgOriginY - tileMaxYMeters) / imageResolution;
-        // 6. Snap to Integer Grid (The "Force 256" Fix)
-        // We round the start position to align with the nearest pixel.
-        const FETCH_SIZE = fetchSize || TILE_SIZE; // Default to 256 if not provided
-        const startX = Math.round(windowMinX);
-        const startY = Math.round(windowMinY);
-        const endX = startX + FETCH_SIZE;
-        const endY = startY + FETCH_SIZE;
-        // --- STEP 3: CALCULATE INTERSECTION ---
-        // 7. Clamp the read window to the actual image dimensions
-        // This defines the "Safe" area we can actually read from the file.
-        const validReadX = Math.max(0, startX);
-        const validReadY = Math.max(0, startY);
-        const validReadMaxX = Math.min(imageWidth, endX);
-        const validReadMaxY = Math.min(imageHeight, endY);
-        const readWidth = validReadMaxX - validReadX;
-        const readHeight = validReadMaxY - validReadY;
-        // CHECK: If no overlap, return empty
-        if (readWidth <= 0 || readHeight <= 0) {
-            return [this.createEmptyTile(FETCH_SIZE)];
-        }
-        // 8. Calculate Offsets (Padding)
-        // "missingLeft" is how many blank pixels we need to insert before the image data starts.
-        // Logic: If we wanted to read from -50 (startX), but clamped to 0 (validReadX),
-        // we are missing the first 50 pixels.
-        const missingLeft = validReadX - startX;
-        const missingTop = validReadY - startY;
-        const window = [validReadX, validReadY, validReadMaxX, validReadMaxY];
-        // --- STEP 4: READ AND COMPOSITE ---
-        // Case A: Partial Overlap (Padding or Cropping required)
-        // If the tile is hanging off the edge, we need to manually reconstruct it.
-        // We strictly compare against FETCH_SIZE because that is our target buffer dimension.
-        if (missingLeft > 0 || missingTop > 0 || readWidth < FETCH_SIZE || readHeight < FETCH_SIZE) {
-            const numChannels = this.options.numOfChannels || 1;
-            // Initialize with a TypedArray of the full target size and correct data type
-            const validImageData = this.createTileBuffer(this.options.format || 'Float32', FETCH_SIZE, numChannels);
-            if (this.options.noDataValue !== undefined) {
-                validImageData.fill(this.options.noDataValue);
-            }
-            // if the valid window is smaller than the tile size, it gets the image size width and height, thus validRasterData.width must be used as below
-            const validRasterData = await targetImage.readRasters({ window });
-            // Place the valid pixel data into the tile buffer.
-            for (let band = 0; band < validRasterData.length; band += 1) {
-                // We must reset the buffer for each band, otherwise data from previous band persists in padding areas
-                const tileBuffer = this.createTileBuffer(this.options.format || 'Float32', FETCH_SIZE);
+        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 closestIndex;
+    }
+    async getTileFromImage(tileX, tileY, zoom, fetchSize, signal) {
+        // Create a fresh local AbortController for this specific fetch.
+        // We do NOT pass `signal` directly to readRasters because deck.gl may reuse tile
+        // objects whose signal is already aborted (same tile re-requested after viewport change).
+        // An already-aborted signal passed to geotiff.js immediately cancels the fetch,
+        // leaving the tile permanently empty. Instead, we only forward cancellation when
+        // the signal fires WHILE the request is actually in flight.
+        const controller = new AbortController();
+        if (signal && !signal.aborted) {
+            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
+            let imagePromise = this.imageCache.get(imageIndex);
+            if (!imagePromise) {
+                imagePromise = this.cog.getImage(imageIndex);
+                this.imageCache.set(imageIndex, imagePromise);
+            }
+            const targetImage = await imagePromise;
+            // --- STEP 1: CALCULATE BOUNDS IN METERS ---
+            // 2. Get COG Metadata (image = COG)
+            const imageResolution = this.cogResolutionLookup[imageIndex];
+            const imageHeight = targetImage.getHeight();
+            const imageWidth = targetImage.getWidth();
+            const [imgOriginX, imgOriginY] = this.cogOrigin;
+            // 3. Define Web Mercator Constants
+            // We use the class property tileSize (usually 256) as the ground truth for grid calculations
+            const TILE_SIZE = this.tileSize;
+            const ORIGIN_X = webMercatorOrigin[0];
+            const ORIGIN_Y = webMercatorOrigin[1];
+            // 4. Calculate Tile BBox in World Meters
+            // This defines where the map expects the tile to be physically located
+            const tileGridResolution = (EARTH_CIRCUMFERENCE / TILE_SIZE) / (2 ** zoom);
+            const tileMinXMeters = ORIGIN_X + (tileX * TILE_SIZE * tileGridResolution);
+            const tileMaxYMeters = ORIGIN_Y - (tileY * TILE_SIZE * tileGridResolution);
+            // Note: We don't strictly need MaxX/MinY meters for the start calculation,
+            // but they are useful if debugging the full meter footprint.
+            // --- STEP 2: CONVERT TO PIXEL COORDINATES ---
+            // 5. Calculate precise floating-point start position relative to the image
+            const windowMinX = (tileMinXMeters - imgOriginX) / imageResolution;
+            const windowMinY = (imgOriginY - tileMaxYMeters) / imageResolution;
+            // 6. Snap to Integer Grid (The "Force 256" Fix)
+            // We round the start position to align with the nearest pixel.
+            const FETCH_SIZE = fetchSize || TILE_SIZE; // Default to 256 if not provided
+            const startX = Math.round(windowMinX);
+            const startY = Math.round(windowMinY);
+            const endX = startX + FETCH_SIZE;
+            const endY = startY + FETCH_SIZE;
+            // --- STEP 3: CALCULATE INTERSECTION ---
+            // 7. Clamp the read window to the actual image dimensions
+            // This defines the "Safe" area we can actually read from the file.
+            const validReadX = Math.max(0, startX);
+            const validReadY = Math.max(0, startY);
+            const validReadMaxX = Math.min(imageWidth, endX);
+            const validReadMaxY = Math.min(imageHeight, endY);
+            const readWidth = validReadMaxX - validReadX;
+            const readHeight = validReadMaxY - validReadY;
+            // CHECK: If no overlap, return empty
+            if (readWidth <= 0 || readHeight <= 0) {
+                return [this.createEmptyTile(FETCH_SIZE)];
+            }
+            // 8. Calculate Offsets (Padding)
+            // "missingLeft" is how many blank pixels we need to insert before the image data starts.
+            // Logic: If we wanted to read from -50 (startX), but clamped to 0 (validReadX),
+            // we are missing the first 50 pixels.
+            const missingLeft = validReadX - startX;
+            const missingTop = validReadY - startY;
+            const window = [validReadX, validReadY, validReadMaxX, validReadMaxY];
+            // --- STEP 4: READ AND COMPOSITE ---
+            // Case A: Partial Overlap (Padding or Cropping required)
+            // If the tile is hanging off the edge, we need to manually reconstruct it.
+            // We strictly compare against FETCH_SIZE because that is our target buffer dimension.
+            if (missingLeft > 0 || missingTop > 0 || readWidth < FETCH_SIZE || readHeight < FETCH_SIZE) {
+                const numChannels = this.options.numOfChannels || 1;
+                // Initialize with a TypedArray of the full target size and correct data type
+                const validImageData = this.createTileBuffer(this.options.format || 'Float32', FETCH_SIZE, numChannels);
                 if (this.options.noDataValue !== undefined) {
-                    tileBuffer.fill(this.options.noDataValue);
+                    validImageData.fill(this.options.noDataValue);
                 }
-                for (let row = 0; row < readHeight; row += 1) {
-                    const destRow = missingTop + row;
-                    const destRowOffset = destRow * FETCH_SIZE;
-                    const srcRowOffset = row * validRasterData.width;
-                    for (let col = 0; col < readWidth; col += 1) {
-                        // Compute the destination position in the tile buffer.
-                        const destCol = missingLeft + col;
-                        // Bounds Check: Ensure we don't write outside the allocated buffer
-                        if (destRow < FETCH_SIZE && destCol < FETCH_SIZE) {
-                            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}`);
+                // if the valid window is smaller than the tile size, it gets the image size width and height, thus validRasterData.width must be used as below
+                const validRasterData = await targetImage.readRasters({ window, signal: localSignal });
+                // Place the valid pixel data into the tile buffer.
+                for (let band = 0; band < validRasterData.length; band += 1) {
+                    // We must reset the buffer for each band, otherwise data from previous band persists in padding areas
+                    const tileBuffer = this.createTileBuffer(this.options.format || 'Float32', FETCH_SIZE);
+                    if (this.options.noDataValue !== undefined) {
+                        tileBuffer.fill(this.options.noDataValue);
+                    }
+                    for (let row = 0; row < readHeight; row += 1) {
+                        const destRow = missingTop + row;
+                        const destRowOffset = destRow * FETCH_SIZE;
+                        const srcRowOffset = row * validRasterData.width;
+                        for (let col = 0; col < readWidth; col += 1) {
+                            // Compute the destination position in the tile buffer.
+                            const destCol = missingLeft + col;
+                            // Bounds Check: Ensure we don't write outside the allocated buffer
+                            if (destRow < FETCH_SIZE && destCol < FETCH_SIZE) {
+                                tileBuffer[destRowOffset + destCol] = validRasterData[band][srcRowOffset + col];
+                            }
+                            else {
+                                console.error(`[CogTiles] tile buffer bounds exceeded: destRow ${destRow}, destCol ${destCol}, FETCH_SIZE ${FETCH_SIZE}`);
+                            }
                         }
                     }
+                    for (let i = 0; i < tileBuffer.length; i += 1) {
+                        validImageData[i * numChannels + band] = tileBuffer[i];
+                    }
                 }
-                for (let i = 0; i < tileBuffer.length; i += 1) {
-                    validImageData[i * numChannels + band] = tileBuffer[i];
-                }
+                // Mark raster as cached after successful fetch
+                this.setCachedRaster(cacheKey, validImageData); // for partial overlap
+                return [validImageData];
             }
-            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) {
+            // If the signal was aborted (or geotiff.js threw AggregateError wrapping an abort),
+            // re-throw as a standard AbortError so deck.gl handles tile cancellation gracefully
+            // and suppressGlobalAbortErrors() can suppress the unhandled rejection noise.
+            const isAbortRelated = localSignal.aborted
+                || (error instanceof AggregateError && error.errors?.some((e) => e?.name === 'AbortError' || e?.message?.includes('aborted') || e?.message?.includes('abort')))
+                || (error instanceof DOMException && error.name === 'AbortError')
+                || (error instanceof Error && error.message === 'Request was aborted');
+            if (isAbortRelated) {
+                throw new DOMException('Tile request aborted', 'AbortError');
+            }
+            throw error;
         }
-        // Case B: Perfect Match (Optimization)
-        // If the read window is exactly 256x256 and aligned, we can read directly interleaved.
-        // console.log("Perfect aligned read");
-        const tileData = await targetImage.readRasters({ window, interleave: true });
-        // console.log(`data that starts at the left top corner of the tile ${tileX}, ${tileY}`);
-        return [tileData];
     }
     /**
      * Creates a blank tile buffer filled with the "No Data" value.
@@ -6954,7 +7066,7 @@ class CogTiles {
         }
         return tileData;
     }
-    async getTile(x, y, z, bounds, meshMaxError) {
+    async getTile(x, y, z, bounds, meshMaxError, signal) {
         let requiredSize = this.tileSize; // Default 256 for image/bitmap
         if (this.options.type === 'terrain') {
             const isKernel = this.options.useSlope || this.options.useHillshade || this.options.useSwissRelief;
@@ -6964,7 +7076,7 @@ class CogTiles {
             // Bitmap layer with relief glaze mode needs kernel padding for slope/hillshade computation
             requiredSize = this.tileSize + 2; // 258 for kernel
         }
-        const tileData = await this.getTileFromImage(x, y, z, requiredSize);
+        const tileData = await this.getTileFromImage(x, y, z, requiredSize, signal);
         // Compute true ground cell size in meters from tile indices.
         // Tile y in slippy-map convention → center latitude → Web Mercator distortion correction.
         const latRad = Math.atan(Math.sinh(Math.PI * (1 - 2 * (y + 0.5) / Math.pow(2, z))));
@@ -6984,13 +7096,17 @@ 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,
             height: tileHeight,
-            bounds,
+            bounds: bounds ?? [0, 0, 0, 0],
             cellSizeMeters,
-        }, this.options, meshMaxError);
+        }, this.options, meshMaxError ?? 4.0);
     }
     /**
      * Determines the data type (e.g., "Int32", "Float64") of a GeoTIFF image
@@ -7200,20 +7316,11 @@ class CogBitmapLayer extends CompositeLayer {
         }
     }
     async getTiledBitmapData(tile) {
-        try {
-            // TODO - pass signal to getTile
-            // abort request if signal is aborted
-            const tileData = await this.state.bitmapCogTiles.getTile(tile.index.x, tile.index.y, tile.index.z);
-            if (tileData && !this.props.pickable) {
-                tileData.raw = null;
-            }
-            return tileData;
-        }
-        catch (error) {
-            // Log the error and rethrow so TileLayer can surface the failure via onTileError
-            log.warn(`Failed to load bitmap tile at ${tile.index.z}/${tile.index.x}/${tile.index.y}:`, error)();
-            throw error;
+        const resolvedTileData = await this.state.bitmapCogTiles.getTile(tile.index.x, tile.index.y, tile.index.z, undefined, undefined, tile.signal);
+        if (resolvedTileData && !this.props.pickable) {
+            resolvedTileData.raw = null;
         }
+        return resolvedTileData;
     }
     renderSubLayers(props) {
         const SubLayerClass = this.getSubLayerClass('image', BitmapLayer);
@@ -7347,7 +7454,6 @@ function urlTemplateToUpdateTrigger(template) {
 }
 // TODO remove elevationDecoder
 // TODO use meshMaxError
-// TODO - pass signal to getTile
 /** Render mesh surfaces from height map images. */
 class CogTerrainLayer extends CompositeLayer {
     static defaultProps = defaultProps;
@@ -7446,13 +7552,11 @@ class CogTerrainLayer extends CompositeLayer {
             topRight = [bbox.right, bbox.top];
         }
         const bounds = [bottomLeft[0], bottomLeft[1], topRight[0], topRight[1]];
-        // TODO - pass signal to getTile
-        // abort request if signal is aborted
-        const terrain = await this.state.terrainCogTiles.getTile(tile.index.x, tile.index.y, tile.index.z, bounds, this.props.meshMaxError);
-        if (terrain && !this.props.pickable) {
-            terrain.raw = null;
+        const resolvedTerrain = await this.state.terrainCogTiles.getTile(tile.index.x, tile.index.y, tile.index.z, bounds, this.props.meshMaxError, tile.signal);
+        if (resolvedTerrain && !this.props.pickable) {
+            resolvedTerrain.raw = null;
         }
-        return Promise.all([terrain, null]);
+        return Promise.all([resolvedTerrain, null]);
     }
     renderSubLayers(props) {
         const SubLayerClass = this.getSubLayerClass('mesh', SimpleMeshLayer);
@@ -7561,6 +7665,10 @@ class CogTerrainLayer extends CompositeLayer {
     }
 }
 
+// src/index.ts
+// Initialize global error suppression for deck.gl AbortErrors
+suppressGlobalAbortErrors();
+
 class RawDecoder extends BaseDecoder {
     /** @param {ArrayBuffer} buffer */
     decodeBlock(buffer) {
@@ -7569,8 +7677,8 @@ class RawDecoder extends BaseDecoder {
 }
 
 var raw = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  default: RawDecoder
+    __proto__: null,
+    default: RawDecoder
 });
 
 const MIN_BITS = 9;
@@ -7728,8 +7836,8 @@ class LZWDecoder extends BaseDecoder {
 }
 
 var lzw = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  default: LZWDecoder
+    __proto__: null,
+    default: LZWDecoder
 });
 
 /* -*- tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- /
@@ -8792,8 +8900,8 @@ class JpegDecoder extends BaseDecoder {
 }
 
 var jpeg = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  default: JpegDecoder
+    __proto__: null,
+    default: JpegDecoder
 });
 
 /*============================================================================*/
@@ -12039,8 +12147,8 @@ class DeflateDecoder extends BaseDecoder {
 }
 
 var deflate = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  default: DeflateDecoder
+    __proto__: null,
+    default: DeflateDecoder
 });
 
 class PackbitsDecoder extends BaseDecoder {
@@ -12070,8 +12178,8 @@ class PackbitsDecoder extends BaseDecoder {
 }
 
 var packbits = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  default: PackbitsDecoder
+    __proto__: null,
+    default: PackbitsDecoder
 });
 
 function getDefaultExportFromCjs (x) {
@@ -14525,9 +14633,9 @@ class LercDecoder extends BaseDecoder {
 }
 
 var lerc = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  default: LercDecoder,
-  zstd: zstd$2
+    __proto__: null,
+    default: LercDecoder,
+    zstd: zstd$2
 });
 
 /**
@@ -14701,9 +14809,9 @@ class ZstdDecoder extends BaseDecoder {
 }
 
 var zstd$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  default: ZstdDecoder,
-  zstd: zstd
+    __proto__: null,
+    default: ZstdDecoder,
+    zstd: zstd
 });
 
 /**
@@ -14766,9 +14874,9 @@ class WebImageDecoder extends BaseDecoder {
 }
 
 var webimage = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  default: WebImageDecoder
+    __proto__: null,
+    default: WebImageDecoder
 });
 
-export { CogBitmapLayer, CogTerrainLayer, CogTiles, GeoImage };
+export { CogBitmapLayer, CogTerrainLayer, CogTiles, GeoImage, suppressGlobalAbortErrors };
 //# sourceMappingURL=index.js.map