maplibre-gl-raster 0.4.0 → 0.5.0

package/dist/{RasterControl-90FXg5Gi.js → RasterControl-vzjXiCsa.js}

@@ -17263,10 +17263,18 @@ var WEB_MERCATOR_CODES = new Set([
 	102100,
 	102113
 ]);
+var GEOGRAPHIC_WGS84 = 4326;
+var EARTH_RADIUS = 6378137;
+var DEG2RAD = Math.PI / 180;
 var identity = (x, y) => [x, y];
+var geographicTo3857 = (lon, lat) => [EARTH_RADIUS * lon * DEG2RAD, EARTH_RADIUS * Math.log(Math.tan(Math.PI / 4 + lat * DEG2RAD / 2))];
+var geographicFrom3857 = (x, y) => [x / EARTH_RADIUS / DEG2RAD, (2 * Math.atan(Math.exp(y / EARTH_RADIUS)) - Math.PI / 2) / DEG2RAD];
 function isWebMercatorCrs(crs) {
 	return typeof crs === "number" && WEB_MERCATOR_CODES.has(crs);
 }
+function isGeographicWgs84Crs(crs) {
+	return crs === GEOGRAPHIC_WGS84;
+}
 /**
 * {@link COGLayer} that reprojects a Web-Mercator source with the identity
 * transform instead of a proj4 round-trip.
@@ -17287,23 +17295,33 @@ function isWebMercatorCrs(crs) {
 *
 * For a source already in EPSG:3857 the source→3857 transform *is* the
 * identity, so we substitute it directly: exact (no precision loss), wrap-free,
-* and cheaper than proj4. The 4326 transforms are deliberately left untouched —
-* they are a genuine inverse mercator and back the geographic bounds and the
-* globe view.
+* and cheaper than proj4. For a geographic EPSG:4326 source — equally common
+* for global rasters, e.g. the CHIRPS precipitation COG — the source→3857
+* transform is the spherical mercator forward, which we substitute with a
+* wrap-free implementation (`geographicTo3857`) so the antimeridian padding
+* columns no longer fold to the other hemisphere. Both substitutions only
+* touch the source↔3857 transforms; the 4326 bounds transforms are left
+* untouched — they back the geographic bounds and the globe view.
 *
 * The fix lives here rather than upstream because deck.gl-geotiff hard-codes the
 * projection setup inside `_parseGeoTIFF` and exposes no hook for it;
 * `_tilesetDescriptor()` is the one seam through which the built descriptor
 * flows to both tile traversal and per-tile rendering. Remove this once
-* deck.gl-geotiff short-circuits same-CRS reprojection itself.
+* deck.gl-geotiff short-circuits same-CRS reprojection and clamps the
+* antimeridian overhang itself.
 */
 var WebMercatorCOGLayer = class extends COGLayer {
 	static layerName = "WebMercatorCOGLayer";
 	_tilesetDescriptor() {
 		const descriptor = super._tilesetDescriptor();
-		if (descriptor && descriptor.projectTo3857 !== identity && isWebMercatorCrs(this.state.geotiff?.crs)) {
+		if (!descriptor) return descriptor;
+		const crs = this.state.geotiff?.crs;
+		if (descriptor.projectTo3857 !== identity && isWebMercatorCrs(crs)) {
 			descriptor.projectTo3857 = identity;
 			descriptor.projectFrom3857 = identity;
+		} else if (descriptor.projectTo3857 !== geographicTo3857 && isGeographicWgs84Crs(crs)) {
+			descriptor.projectTo3857 = geographicTo3857;
+			descriptor.projectFrom3857 = geographicFrom3857;
 		}
 		return descriptor;
 	}
@@ -18067,7 +18085,50 @@ function deriveLayerName(source) {
 //#region src/lib/state/LayerManager.ts
 /** Default engine when none is configured: the deck.gl GPU pipeline. */
 var DEFAULT_ENGINE = "maplibre-gl-raster";
-var getTileData = makeMultiBandTileLoader(Array.from({ length: 4 }, (_, i) => i + 1));
+/**
+* The band indexes a layer actually samples, deduped and sorted. Mirrors the
+* `requested` logic in render-pipeline's buildRenderTile: RGB samples the first
+* three entries (R, G, B); single-band / colormap / palette the first one. The
+* render pipeline looks textures up by band number, not slot order, so the
+* fetch order is irrelevant — sorting makes the set order-independent, so
+* reassigning RGB channels among the same bands does not force a refetch.
+* Always yields at least band 1 so a layer with an empty/invalid selection
+* still fetches something to draw.
+*
+* The sampled channels are sliced off **before** dedupe/sort so a state that
+* carries more entries than channels (e.g. `bands: [12, 1, 2, 3, 4]`) can't
+* sort-then-cap a band that a channel still samples (here the red channel's
+* 12) out of the fetched set. By construction the result is ≤ 3 entries — well
+* within the CompositeBands shader's {@link MAX_BAND_SLOTS} texture slots.
+*/
+function fetchBandsFor(layer) {
+	const bands = layer.state.bands;
+	const sampled = layer.state.mode === "rgb" ? (bands && bands.length > 0 ? bands : [
+		1,
+		2,
+		3
+	]).slice(0, 3) : [bands?.[0] ?? 1];
+	const unique = [...new Set(sampled.filter((b) => Number.isInteger(b) && b >= 1))].sort((a, b) => a - b);
+	if (unique.length === 0) unique.push(1);
+	return unique.slice(0, 4);
+}
+/**
+* The deck.gl layer id for a raster layer, with its fetched band set encoded.
+*
+* The tile loader only fetches {@link fetchBandsFor} (≤ MAX_BAND_SLOTS) bands,
+* so a single-band view of e.g. band 12 needs band 12 in the tile textures.
+* deck.gl's `TileLayer` does **not** refetch when `getTileData` changes — its
+* RasterTileLayer wrapper sets no `getTileData` updateTrigger, so a swapped
+* loader closure is silently ignored and the previously fetched bands stay
+* cached. The one reliable way to refetch is to remount the layer, which
+* deck.gl does when the layer id changes. Encoding the (sorted) band set in the
+* id therefore makes a band-selection change refetch the newly selected bands,
+* while leaving the id — and thus the tile cache — stable across opacity,
+* colormap, rescale and RGB-channel-reorder changes that don't alter the set.
+*/
+function cogLayerId(layer, fetchBands) {
+	return `${layer.id}#b${fetchBands.join("-")}`;
+}
 /** Uploads an embedded color table as a 2D-array texture for the Colormap
 * shader module. Unlike `createColormapTexture` (which uses linear filtering
 * for smooth continuous colormaps), palette lookups must be NEAREST-filtered:
@@ -18600,8 +18661,10 @@ var LayerManager = class {
 	}
 	_buildCogLayer(layer) {
 		const renderTile = this._renderTileFor(layer);
+		const fetchBands = fetchBandsFor(layer);
+		const getTileData = makeMultiBandTileLoader(fetchBands);
 		return new WebMercatorCOGLayer({
-			id: layer.id,
+			id: cogLayerId(layer, fetchBands),
 			geotiff: layer.geotiff,
 			opacity: layer.state.opacity,
 			getTileData,
@@ -19548,7 +19611,7 @@ var SettingsSection = class {
 		}
 		const state = layer.state;
 		const mode = state.mode;
-		const bandOptions = Array.from({ length: Math.min(layer.bandCount ?? 4, 4) }, (_, i) => i + 1);
+		const bandOptions = Array.from({ length: Math.max(1, layer.bandCount ?? 1) }, (_, i) => i + 1);
 		const paletteActive = mode === "single" && state.colormap === "palette" && layer.palette !== null;
 		this._body.appendChild(this._buildModeField(state, mode, bandOptions));
 		this._body.appendChild(this._buildBandsField(layer, state, mode, bandOptions));
@@ -20897,4 +20960,4 @@ var RasterControl = class {
 //#endregion
 export { computeAutoStats as C, createResilientEpsgResolver as E, MAX_SAMPLE_TILES as S, readBandNames as T, COLORMAP_ROW_COUNT as _, loadColormapSprite as a, autoRangeFor as b, classNames as c, generateId as d, throttle as f, COLORMAP_OPTIONS as g, COLORMAP_NAMES as h, isKnownColormap as i, debounce as l, COLORMAP_DISPLAY_NAMES as m, Colorbar as n, sampleColormapStops as o, loadGeoTIFF as p, PALETTE_COLORMAP as r, clamp as s, RasterControl as t, formatNumericValue as u, colormapDisplayName as v, percentileFromHistogram as w, statsForBand as x, colormaps_default as y };
 
-//# sourceMappingURL=RasterControl-90FXg5Gi.js.map
+//# sourceMappingURL=RasterControl-vzjXiCsa.js.map