maplibre-gl-raster 0.13.0 → 0.14.0

package/dist/{RasterControl-BDDduhO9.js → RasterControl-hvApJoZQ.js}

@@ -19065,6 +19065,149 @@ function classNames(classes) {
 	return Object.entries(classes).filter(([, value]) => value).map(([key]) => key).join(" ");
 }
 //#endregion
+//#region src/lib/state/RasterLayer.ts
+/** Default visualization state for a freshly added layer. Mode/bands are
+* re-picked automatically once the band count is known (unless the caller
+* supplied them explicitly); single-band rasters default to the image's
+* embedded color table when present ('palette') or grayscale otherwise. */
+var DEFAULT_LAYER_STATE = {
+	mode: "rgb",
+	bands: [
+		1,
+		2,
+		3
+	],
+	rescale: null,
+	colormap: "gray",
+	reversed: false,
+	nodata: "auto",
+	opacity: 1,
+	gamma: 1,
+	stretch: "linear",
+	visible: true,
+	minZoom: 0,
+	maxZoom: 24
+};
+/**
+* Creates a complete layer state from optional overrides.
+*
+* @param overrides - Partial state merged over the defaults
+* @returns A fully populated RasterLayerState
+*/
+function createLayerState(overrides) {
+	return {
+		...DEFAULT_LAYER_STATE,
+		...overrides
+	};
+}
+/**
+* Resolves a layer's min/max zoom bounds, filling in the full [0, 24] range for
+* any bound left unset. Shared by the render engines so the deck.gl overlay and
+* the native MapLibre raster layers apply an identical zoom range.
+*
+* @param state - The layer state (only its zoom bounds are read)
+* @returns The concrete `{ minZoom, maxZoom }` bounds
+*/
+function resolveZoomRange(state) {
+	return {
+		minZoom: state.minZoom ?? 0,
+		maxZoom: state.maxZoom ?? 24
+	};
+}
+/**
+* Derives the public snapshot for a layer.
+*
+* @param layer - Internal layer record
+* @returns A read-only info object safe to hand to consumers
+*/
+function toLayerInfo(layer) {
+	return {
+		id: layer.id,
+		name: layer.name,
+		source: layer.source,
+		memberUrls: layer.members ? layer.members.map((m) => m.url) : null,
+		bandCount: layer.bandCount,
+		bandNames: layer.bandNames ? new Map(layer.bandNames) : null,
+		beforeId: layer.beforeId,
+		attribution: layer.attribution,
+		bounds: layer.bounds ? { ...layer.bounds } : null,
+		loading: layer.loading,
+		error: layer.error,
+		state: { ...layer.state }
+	};
+}
+/** True when `lngLat` falls inside `bounds` (edges included). */
+function containsPoint(bounds, lngLat) {
+	const [lng, lat] = lngLat;
+	return lng >= bounds.west && lng <= bounds.east && lat >= bounds.south && lat <= bounds.north;
+}
+/**
+* The layer's images that could carry a sample at `lngLat`, topmost first.
+*
+* A plain layer has exactly one image. A mosaic VRT layer has one per member,
+* and only the members whose extent covers the point are worth reading — a
+* member whose bounds have not been reported yet stays a candidate rather than
+* being skipped, since bounds only arrive once a member renders.
+*
+* Members are returned in reverse document order because that is the order they
+* are drawn in: `LayerManager` builds one deck.gl layer per member in member
+* order, so later members paint over earlier ones — matching GDAL, where a
+* VRT's later sources overwrite earlier ones. Sources placed at their natural
+* position can still overlap (adjacent scenes commonly do), so where they do,
+* the last one is what the user sees and therefore what a reader should report.
+*
+* @param layer - The layer to read from
+* @param lngLat - The location, [lng, lat] in WGS84
+* @returns Candidate images, topmost first; empty when the layer has not loaded
+*   or the point falls outside every member
+*/
+function imagesAt(layer, lngLat) {
+	if (!layer.members) return layer.geotiff ? [layer.geotiff] : [];
+	return layer.members.filter((m) => !m.bounds || containsPoint(m.bounds, lngLat)).reverse().map((m) => m.geotiff);
+}
+/**
+* The mosaic assets whose extent covers `lngLat`, in manifest order.
+*
+* A mosaic manifest layer (MosaicJSON or STAC) has no opened image of its own —
+* the deck.gl {@link import('@developmentseed/deck.gl-geotiff').MosaicLayer}
+* opens each asset lazily while it is in view — so a reader works from the
+* manifest's bboxes and opens what it needs. This is the mosaic counterpart to
+* {@link imagesAt}, returning URLs because the COGs may not be open yet.
+*
+* Unlike a VRT's members these are *not* reversed. A VRT has a defined paint
+* order (later sources overwrite earlier ones), but a mosaic's assets are drawn
+* in whatever order its spatial index returns them, so no candidate is reliably
+* "topmost". Manifest order is used instead: it matches MosaicJSON's convention
+* that the first asset listed for a location is the preferred one. Where assets
+* genuinely overlap the drawn pixel is ambiguous, and the first covering asset
+* is as defensible a report as any.
+*
+* @param layer - The layer to read from
+* @param lngLat - The location, [lng, lat] in WGS84
+* @returns Covering asset URLs in manifest order; empty when the layer is not a
+*   mosaic manifest, has not parsed yet, or the point falls outside every asset
+*/
+function assetsAt(layer, lngLat) {
+	if (!layer.mosaicAssets) return [];
+	const [lng, lat] = lngLat;
+	return layer.mosaicAssets.filter((a) => lng >= a.bbox[0] && lng <= a.bbox[2] && lat >= a.bbox[1] && lat <= a.bbox[3]).map((a) => a.url);
+}
+/**
+* Derives a display name from a URL or file name: the last path segment
+* without query string.
+*
+* @param source - URL string or file name
+* @returns A short human-readable layer name
+*/
+function deriveLayerName(source) {
+	try {
+		const segment = (source.includes("://") ? new URL(source).pathname : source).split("/").filter(Boolean).pop();
+		return segment ? decodeURIComponent(segment) : source;
+	} catch {
+		return source;
+	}
+}
+//#endregion
 //#region src/lib/state/CogTilerEngine.ts
 /**
 * The colormaps assumed renderable before the wasm module has loaded.
@@ -19407,7 +19550,11 @@ var CogTilerEngine = class {
 			assets: layer.assets ?? null,
 			render
 		});
-		if (this._map.getLayer(lyrId)) this._map.setPaintProperty(lyrId, "raster-opacity", layer.state.opacity);
+		if (this._map.getLayer(lyrId)) {
+			this._map.setPaintProperty(lyrId, "raster-opacity", layer.state.opacity);
+			const { minZoom, maxZoom } = resolveZoomRange(layer.state);
+			this._map.setLayerZoomRange(lyrId, minZoom, maxZoom);
+		}
 	}
 	_addMapLayer(layer, renderKey) {
 		const srcId = this._srcId(layer.id);
@@ -19712,10 +19859,13 @@ var TiTilerEngine = class {
 				...tilejson.bounds ? { bounds: tilejson.bounds } : {},
 				...typeof tilejson.maxzoom === "number" ? { maxzoom: tilejson.maxzoom } : {}
 			});
+			const { minZoom, maxZoom } = resolveZoomRange(layer.state);
 			this._map.addLayer({
 				id: lyrId,
 				type: "raster",
 				source: srcId,
+				minzoom: minZoom,
+				maxzoom: maxZoom,
 				paint: { "raster-opacity": layer.state.opacity }
 			}, this._beforeMapId(layer));
 		} catch (err) {
@@ -19747,7 +19897,11 @@ var TiTilerEngine = class {
 	}
 	_setOpacity(layer) {
 		const lyrId = this._lyrId(layer.id);
-		if (this._map.getLayer(lyrId)) this._map.setPaintProperty(lyrId, "raster-opacity", layer.state.opacity);
+		if (this._map.getLayer(lyrId)) {
+			this._map.setPaintProperty(lyrId, "raster-opacity", layer.state.opacity);
+			const { minZoom, maxZoom } = resolveZoomRange(layer.state);
+			this._map.setLayerZoomRange(lyrId, minZoom, maxZoom);
+		}
 	}
 	/** Enforces the draw order (first = bottom), honoring each layer's style
 	* beforeId when present. */
@@ -20079,133 +20233,6 @@ async function loadMosaic(url, signal) {
 	return parseMosaic(await resp.json());
 }
 //#endregion
-//#region src/lib/state/RasterLayer.ts
-/** Default visualization state for a freshly added layer. Mode/bands are
-* re-picked automatically once the band count is known (unless the caller
-* supplied them explicitly); single-band rasters default to the image's
-* embedded color table when present ('palette') or grayscale otherwise. */
-var DEFAULT_LAYER_STATE = {
-	mode: "rgb",
-	bands: [
-		1,
-		2,
-		3
-	],
-	rescale: null,
-	colormap: "gray",
-	reversed: false,
-	nodata: "auto",
-	opacity: 1,
-	gamma: 1,
-	stretch: "linear",
-	visible: true
-};
-/**
-* Creates a complete layer state from optional overrides.
-*
-* @param overrides - Partial state merged over the defaults
-* @returns A fully populated RasterLayerState
-*/
-function createLayerState(overrides) {
-	return {
-		...DEFAULT_LAYER_STATE,
-		...overrides
-	};
-}
-/**
-* Derives the public snapshot for a layer.
-*
-* @param layer - Internal layer record
-* @returns A read-only info object safe to hand to consumers
-*/
-function toLayerInfo(layer) {
-	return {
-		id: layer.id,
-		name: layer.name,
-		source: layer.source,
-		memberUrls: layer.members ? layer.members.map((m) => m.url) : null,
-		bandCount: layer.bandCount,
-		bandNames: layer.bandNames ? new Map(layer.bandNames) : null,
-		beforeId: layer.beforeId,
-		attribution: layer.attribution,
-		bounds: layer.bounds ? { ...layer.bounds } : null,
-		loading: layer.loading,
-		error: layer.error,
-		state: { ...layer.state }
-	};
-}
-/** True when `lngLat` falls inside `bounds` (edges included). */
-function containsPoint(bounds, lngLat) {
-	const [lng, lat] = lngLat;
-	return lng >= bounds.west && lng <= bounds.east && lat >= bounds.south && lat <= bounds.north;
-}
-/**
-* The layer's images that could carry a sample at `lngLat`, topmost first.
-*
-* A plain layer has exactly one image. A mosaic VRT layer has one per member,
-* and only the members whose extent covers the point are worth reading — a
-* member whose bounds have not been reported yet stays a candidate rather than
-* being skipped, since bounds only arrive once a member renders.
-*
-* Members are returned in reverse document order because that is the order they
-* are drawn in: `LayerManager` builds one deck.gl layer per member in member
-* order, so later members paint over earlier ones — matching GDAL, where a
-* VRT's later sources overwrite earlier ones. Sources placed at their natural
-* position can still overlap (adjacent scenes commonly do), so where they do,
-* the last one is what the user sees and therefore what a reader should report.
-*
-* @param layer - The layer to read from
-* @param lngLat - The location, [lng, lat] in WGS84
-* @returns Candidate images, topmost first; empty when the layer has not loaded
-*   or the point falls outside every member
-*/
-function imagesAt(layer, lngLat) {
-	if (!layer.members) return layer.geotiff ? [layer.geotiff] : [];
-	return layer.members.filter((m) => !m.bounds || containsPoint(m.bounds, lngLat)).reverse().map((m) => m.geotiff);
-}
-/**
-* The mosaic assets whose extent covers `lngLat`, in manifest order.
-*
-* A mosaic manifest layer (MosaicJSON or STAC) has no opened image of its own —
-* the deck.gl {@link import('@developmentseed/deck.gl-geotiff').MosaicLayer}
-* opens each asset lazily while it is in view — so a reader works from the
-* manifest's bboxes and opens what it needs. This is the mosaic counterpart to
-* {@link imagesAt}, returning URLs because the COGs may not be open yet.
-*
-* Unlike a VRT's members these are *not* reversed. A VRT has a defined paint
-* order (later sources overwrite earlier ones), but a mosaic's assets are drawn
-* in whatever order its spatial index returns them, so no candidate is reliably
-* "topmost". Manifest order is used instead: it matches MosaicJSON's convention
-* that the first asset listed for a location is the preferred one. Where assets
-* genuinely overlap the drawn pixel is ambiguous, and the first covering asset
-* is as defensible a report as any.
-*
-* @param layer - The layer to read from
-* @param lngLat - The location, [lng, lat] in WGS84
-* @returns Covering asset URLs in manifest order; empty when the layer is not a
-*   mosaic manifest, has not parsed yet, or the point falls outside every asset
-*/
-function assetsAt(layer, lngLat) {
-	if (!layer.mosaicAssets) return [];
-	const [lng, lat] = lngLat;
-	return layer.mosaicAssets.filter((a) => lng >= a.bbox[0] && lng <= a.bbox[2] && lat >= a.bbox[1] && lat <= a.bbox[3]).map((a) => a.url);
-}
-/**
-* Derives a display name from a URL or file name: the last path segment
-* without query string.
-*
-* @param source - URL string or file name
-* @returns A short human-readable layer name
-*/
-function deriveLayerName(source) {
-	try {
-		const segment = (source.includes("://") ? new URL(source).pathname : source).split("/").filter(Boolean).pop();
-		return segment ? decodeURIComponent(segment) : source;
-	} catch {
-		return source;
-	}
-}
-//#endregion
 //#region src/lib/state/LayerManager.ts
 /** Default engine when none is configured: the deck.gl GPU pipeline. */
 var DEFAULT_ENGINE = "maplibre-gl-raster";
@@ -20429,6 +20456,8 @@ var LayerManager = class {
 	_attribStyleReady = false;
 	_onAttribStyleLoad = null;
 	_destroyed = false;
+	_onZoom = null;
+	_zoomVisibleSig = "";
 	/**
 	* Creates a LayerManager bound to a map.
 	*
@@ -20445,6 +20474,8 @@ var LayerManager = class {
 			...DEFAULT_DEPS$1,
 			...deps
 		};
+		this._onZoom = () => this._syncZoomVisibility();
+		this._map.on("zoom", this._onZoom);
 	}
 	/** The id of the layer currently selected for editing, or null. */
 	get selectedId() {
@@ -20934,6 +20965,10 @@ var LayerManager = class {
 			this._map.off("load", this._onAttribStyleLoad);
 			this._onAttribStyleLoad = null;
 		}
+		if (this._onZoom) {
+			this._map.off("zoom", this._onZoom);
+			this._onZoom = null;
+		}
 		if (this._overlay) {
 			this._deps.removeOverlay(this._map, this._overlay);
 			this._overlay = null;
@@ -21241,10 +21276,37 @@ var LayerManager = class {
 			return;
 		}
 		if (!this._overlay) return;
-		const layers = this._layers.filter((l) => (l.geotiff || l.mosaicAssets) && l.state.visible && !this._crsFailed.has(l.id)).flatMap((l) => this._buildCogLayers(l));
+		const renderable = this._layers.filter((l) => (l.geotiff || l.mosaicAssets) && l.state.visible && !this._crsFailed.has(l.id) && this._withinZoomRange(l.state));
+		this._zoomVisibleSig = renderable.map((l) => l.id).join("|");
+		const layers = renderable.flatMap((l) => this._buildCogLayers(l));
 		this._overlay.setProps({ layers });
 	}
 	/**
+	* Whether a layer draws at the map's current zoom, following MapLibre's
+	* per-layer zoom semantics: visible while `minZoom <= zoom < maxZoom`, hidden
+	* outside that. An unset bound falls back to the full [0, 24] range, so a
+	* layer with no constraint always passes.
+	*/
+	_withinZoomRange(state) {
+		const zoom = this._map.getZoom();
+		const min = state.minZoom ?? 0;
+		const max = state.maxZoom ?? 24;
+		return zoom >= min && zoom < max;
+	}
+	/**
+	* Re-renders the deck.gl overlay when the map zoom crosses a layer's min/max
+	* boundary. Runs on every 'zoom' event, so it stays cheap: it rebuilds only
+	* when the set of in-range layers actually changes, leaving pans and in-range
+	* zooms untouched (a needless rebuild would remount the COGLayers and refetch
+	* their tiles). The native engines carry their zoom range on the MapLibre
+	* layer itself, so this is a no-op for them.
+	*/
+	_syncZoomVisibility() {
+		if (this._engine !== "maplibre-gl-raster" || !this._overlay) return;
+		if (this._layers.filter((l) => (l.geotiff || l.mosaicAssets) && l.state.visible && !this._crsFailed.has(l.id) && this._withinZoomRange(l.state)).map((l) => l.id).join("|") === this._zoomVisibleSig) return;
+		this._rebuild();
+	}
+	/**
 	* The deck.gl layers that draw one managed layer: exactly one for a plain
 	* raster, and one per member for a mosaic VRT.
 	*
@@ -24137,4 +24199,4 @@ var RasterControl = class {
 //#endregion
 export { DEFAULT_TITILER_ENDPOINT as A, COLORMAP_ROW_COUNT as B, throttle as C, loadVrt as D, isVrtUrl as E, loadColormapSprite as F, statsForBand as G, colormaps_default as H, sampleColormapStops as I, mergeAutoStats as J, MAX_SAMPLE_TILES as K, COLORMAP_DISPLAY_NAMES as L, isMosaicJsonUrl as M, PALETTE_COLORMAP as N, parseVrt as O, isKnownColormap as P, createResilientEpsgResolver as Q, COLORMAP_NAMES as R, generateId as S, isVrtFile as T, DEFAULT_INDEX_RANGE as U, colormapDisplayName as V, autoRangeFor as W, percentileFromHistogram as X, mergeBandStats as Y, readBandNames as Z, parseMosaic as _, NORMALIZED_DIFFERENCE_INDICES as a, debounce as b, readPixelValues as c, MAX_MOSAIC_ASSETS as d, MosaicUnsupportedError as f, mosaicMinZoom as g, mosaicInitialView as h, CUSTOM_NORMALIZED_DIFFERENCE as i, TITILER_TMS as j, loadGeoTIFF as k, DEFAULT_ENGINE as l, loadMosaic as m, Colorbar as n, guessBandForRole as o, assetUrlToHttps as p, computeAutoStats as q, CUSTOM_INDEX_ID as r, indexById as s, RasterControl as t, LayerManager as u, clamp as v, VrtUnsupportedError as w, formatNumericValue as x, classNames as y, COLORMAP_OPTIONS as z };
 
-//# sourceMappingURL=RasterControl-BDDduhO9.js.map
+//# sourceMappingURL=RasterControl-hvApJoZQ.js.map