@aguacerowx/mapsgl 0.0.31 → 0.0.41

package/index.js

@@ -3,10 +3,42 @@
 // Import the specific classes you want to make public from this package's internal files.
 import { WeatherLayerManager } from './src/WeatherLayerManager.js';
 import { MapManager } from './src/MapManager.js';
+import { NwsWatchesWarningsOverlay, NWS_DEFAULT_LINE_BEFORE_LAYER_ID } from './src/NwsWatchesWarningsOverlay.js';
+import {
+    collectNwsExpressionEventKeys,
+    NWS_ALERT_EVENT_NAMES,
+    NWS_EVENT_COLORS,
+    NWS_SDK_EVENT_COLOR,
+    NWS_SDK_EVENT_NAMES,
+} from './src/nwsSdkConstants.js';
+import {
+    filterNwsAlertsByIncludedList,
+    filterNwsAlertsByScope,
+    filterToConvectiveSdkEvents,
+    isNwsEventIncludedInAllowlist,
+    SDK_ALLOWED_EVENT_SET,
+} from './src/nwsAlertsSupport.js';
 
 // Now, export them both so your test app can import them.
 // This is the "public face" of your @aguacerowx/mapsgl package.
 export {
     WeatherLayerManager,
-    MapManager
-};
+    MapManager,
+    NwsWatchesWarningsOverlay,
+    NWS_DEFAULT_LINE_BEFORE_LAYER_ID,
+    collectNwsExpressionEventKeys,
+    NWS_ALERT_EVENT_NAMES,
+    NWS_EVENT_COLORS,
+    NWS_SDK_EVENT_COLOR,
+    NWS_SDK_EVENT_NAMES,
+    filterNwsAlertsByIncludedList,
+    filterNwsAlertsByScope,
+    filterToConvectiveSdkEvents,
+    isNwsEventIncludedInAllowlist,
+    SDK_ALLOWED_EVENT_SET,
+};
+
+export {
+    DEFAULT_SATELLITE_LONGWAVE_IR_COLORMAP,
+    DEFAULT_SATELLITE_WATER_VAPOR_COLORMAP,
+} from './src/satelliteDefaultColormaps.js';

package/package.json

@@ -1,19 +1,29 @@
 {
   "name": "@aguacerowx/mapsgl",
-  "version": "0.0.31",
+  "version": "0.0.41",
   "private": false,
   "publishConfig": {
     "access": "public"
   },
   "main": "index.js",
   "type": "module",
+  "scripts": {
+    "bundle-nexrad": "esbuild src/nexrad/radarDecode.worker.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/radarDecode.worker.bundled.js && esbuild src/nexrad/radarArchiveCore.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/radarArchiveCore.bundled.js --external:@aguacerowx/javascript-sdk && esbuild src/nexrad/MapboxRadarLayer.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/MapboxRadarLayer.bundled.js --external:mapbox-gl --external:@aguacerowx/javascript-sdk",
+    "gen:nws-key": "esbuild ../../../aguacero-frontend/src/components/WarningsMenu/nwsWarningCustomizationKey.ts --bundle --format=esm --platform=neutral --outfile=src/nwsWarningCustomizationKey.gen.js"
+  },
   "files": [
     "index.js",
     "src"
   ],
+  "devDependencies": {
+    "esbuild": "^0.21.5"
+  },
   "dependencies": {
-    "@aguacerowx/javascript-sdk": "^0.0.18",
+    "@aguacerowx/javascript-sdk": "^0.0.20",
+    "buffer": "^6.0.3",
+    "fzstd": "^0.1.1",
     "mapbox-gl": "^3.4.0",
-    "proj4": "^2.11.0"
+    "proj4": "^2.11.0",
+    "seek-bzip": "^2.0.0"
   }
 }

package/src/GridRenderLayer.js

@@ -2,6 +2,11 @@ import proj4 from 'proj4';
 
 const MERCATOR_SAFE_LIMIT = 89;
 
+/** Mapbox GL 3+ uses a WebGL2 context; LUMINANCE is not a valid sized internal format in WebGL2. */
+function isWebGL2Context(gl) {
+    return typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext;
+}
+
 function hrdpsObliqueTransform(rotated_lon, rotated_lat) {
     const o_lat_p = 53.91148;
     const o_lon_p = 245.305142;
@@ -27,7 +32,18 @@ function hrdpsObliqueTransform(rotated_lon, rotated_lat) {
 }
 
 export class GridRenderLayer {
-    constructor(id) {
+    /**
+     * @param {string | { layerId?: string, id?: string }} idOrOpts - Mapbox custom layer id, or `{ layerId }` / `{ id }` (RN / prop passthrough parity).
+     */
+    constructor(idOrOpts) {
+        let id;
+        if (typeof idOrOpts === 'string') {
+            id = idOrOpts;
+        } else if (idOrOpts != null && typeof idOrOpts === 'object') {
+            id = idOrOpts.layerId ?? idOrOpts.id;
+        } else {
+            id = idOrOpts;
+        }
         this.id = id;
         this.type = 'custom';
         this.renderingMode = '2d';
@@ -110,16 +126,16 @@ export class GridRenderLayer {
             try {
                 return this.map.transform.MercatorCoordinate.fromLngLat({ lon, lat });
             } catch (e) {
-                console.warn('[GridLayer] Failed to use map.transform.MercatorCoordinate:', e);
+                // fall through to manual projection
             }
         }
-        
+
         // Fallback to imported mapboxgl MercatorCoordinate
         if (mapboxgl && mapboxgl.MercatorCoordinate) {
             try {
                 return mapboxgl.MercatorCoordinate.fromLngLat([lon, lat]);
             } catch (e) {
-                console.warn('[GridLayer] Failed to use mapboxgl.MercatorCoordinate:', e);
+                // fall through to manual projection
             }
         }
         
@@ -404,12 +420,13 @@ export class GridRenderLayer {
                         raw_value = dequantize_val(total_value / total_weight);
                     }
                 }
-                
-                if (raw_value < u_data_range.x) {
-                    discard;
-                }
 
                 float converted_value = convert_units(raw_value);
+
+                // Compare against u_data_range in the same unit space as the colormap (after unit conversion).
+                if (converted_value < u_data_range.x) {
+                    discard;
+                }
                 
                 float colormap_coord = clamp((converted_value - u_data_range.x) / (u_data_range.y - u_data_range.x), 0.0, 1.0);
                 
@@ -457,6 +474,39 @@ export class GridRenderLayer {
         }
     }
 
+    /**
+     * Upload quantized grid bytes (Uint8, centered at 128) to the active 2D texture.
+     * WebGL2: R8 + RED + UNSIGNED_BYTE (LUMINANCE is invalid). WebGL1: LUMINANCE.
+     */
+    _uploadQuantizedGridTexture(tex, nx, ny, dataArray) {
+        const gl = this.gl;
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+        if (isWebGL2Context(gl)) {
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.R8, nx, ny, 0, gl.RED, gl.UNSIGNED_BYTE, dataArray);
+        } else {
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.LUMINANCE, nx, ny, 0, gl.LUMINANCE, gl.UNSIGNED_BYTE, dataArray);
+        }
+    }
+
+    /**
+     * After updateDataTexture, register the same GPU texture under timeKey so the slider can
+     * switch back without re-fetching (avoids duplicating VRAM).
+     */
+    registerCurrentDataTextureAsPreloaded(timeKey) {
+        if (!this.gl || !this.dataTexture || this.encoding == null) {
+            return;
+        }
+        if (!this.preloadedTextures) this.preloadedTextures = new Map();
+        if (this.preloadedTextures.has(timeKey)) return;
+        this.preloadedTextures.set(timeKey, {
+            tex: this.dataTexture,
+            encoding: this.encoding,
+            nx: this.textureWidth,
+            ny: this.textureHeight
+        });
+    }
+
     // Call this during preload to store a pre-uploaded GPU texture
     storePreloadedTexture(timeKey, data, encoding, nx, ny) {
         if (!this.gl) return;
@@ -464,13 +514,12 @@ export class GridRenderLayer {
 
         const tex = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, tex);
-        gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
 
         let dataArray = data instanceof Uint8Array ? data
             : data.buffer instanceof ArrayBuffer ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
             : new Uint8Array(data);
 
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.LUMINANCE, nx, ny, 0, gl.LUMINANCE, gl.UNSIGNED_BYTE, dataArray);
+        this._uploadQuantizedGridTexture(tex, nx, ny, dataArray);
 
         const filter = this.noSmoothing ? gl.NEAREST : gl.LINEAR;
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
@@ -480,9 +529,11 @@ export class GridRenderLayer {
         gl.bindTexture(gl.TEXTURE_2D, null);
 
         if (!this.preloadedTextures) this.preloadedTextures = new Map();
-        // Free old texture for this key if it exists
         if (this.preloadedTextures.has(timeKey)) {
-            gl.deleteTexture(this.preloadedTextures.get(timeKey).tex);
+            const prev = this.preloadedTextures.get(timeKey);
+            if (prev.tex && prev.tex !== this.dataTexture) {
+                gl.deleteTexture(prev.tex);
+            }
         }
         this.preloadedTextures.set(timeKey, { tex, encoding, nx, ny });
     }
@@ -499,15 +550,6 @@ export class GridRenderLayer {
         return true;
     }
 
-    // Call in onRemove() to clean up
-    clearPreloadedTextures() {
-        if (!this.gl || !this.preloadedTextures) return;
-        for (const { tex } of this.preloadedTextures.values()) {
-            this.gl.deleteTexture(tex);
-        }
-        this.preloadedTextures.clear();
-    }
-
     updateGeometry(corners, gridDef) {
 
         // Cache the geometry
@@ -523,8 +565,7 @@ export class GridRenderLayer {
                              corners.lon_bl, corners.lat_bl, corners.lon_br, corners.lat_br];
         
         if (coordValues.some(coord => !isFinite(coord))) {
-            console.error('[GridLayer] Invalid corner coordinates:', corners);
-            return;
+                        return;
         }
         
         const gridType = gridDef.type;
@@ -669,17 +710,13 @@ export class GridRenderLayer {
                                         adjustedCorners.lon_br, adjustedCorners.lat_br];
                 
                 if (adjustedCoordValues.some(coord => !isFinite(coord))) {
-                    console.error('[GridLayer] Invalid adjusted corner coordinates:', adjustedCorners);
-                    return;
+                                        return;
                 }
                 
                 // Additional validation: check if latitudes are in valid range
                 const latValues = [adjustedCorners.lat_tl, adjustedCorners.lat_tr, adjustedCorners.lat_bl, adjustedCorners.lat_br];
                 if (latValues.some(lat => lat < -90 || lat > 90)) {
-                    console.error('[GridLayer] Invalid latitude values in corners:', adjustedCorners);
-                    console.error('[GridLayer] Original corners were:', corners);
-                    console.error('[GridLayer] Grid definition:', gridDef);
-                    return;
+                                                                                return;
                 }
                 
                 // Calculate longitude span to handle wrapping
@@ -745,13 +782,7 @@ export class GridRenderLayer {
 
                         // Validate coordinates
                         if (!isFinite(lon) || !isFinite(lat)) {
-                            console.error(`[GridLayer] Invalid interpolated coordinates at ${row},${col}: lon=${lon}, lat=${lat}`);
-                            console.error(`[GridLayer] Interpolation inputs:`, {
-                                t_x, t_y,
-                                corners: adjustedCorners,
-                                gridType: isGFSType ? 'GFS' : (isECMWFType ? 'ECMWF' : (isIconModel ? 'ICON' : 'OTHER'))
-                            });
-                            continue;
+                                                                                    continue;
                         }
 
                         // Normalize longitude to [-180, 180] range
@@ -762,8 +793,7 @@ export class GridRenderLayer {
                         const mercator = this.getMercatorCoordinate(normalizedLon, lat);
                         
                         if (!isFinite(mercator.x) || !isFinite(mercator.y)) {
-                            console.error(`[GridLayer] Invalid Mercator coordinates: x=${mercator.x}, y=${mercator.y}`);
-                            continue;
+                                                        continue;
                         }
                         
                         vertices.push(mercator.x, mercator.y, tex_u, tex_v);
@@ -834,8 +864,7 @@ export class GridRenderLayer {
                         const [lon, lat] = hrdpsObliqueTransform(rot_lon, rot_lat);
                         
                         if (!isFinite(lon) || !isFinite(lat)) {
-                            console.warn(`[GridLayer] Invalid HRDPS transformed coordinates at ${row},${col}: lon=${lon}, lat=${lat}`);
-                            continue;
+                                                        continue;
                         }
                         
                         const clampedLat = Math.max(-MERCATOR_SAFE_LIMIT, Math.min(MERCATOR_SAFE_LIMIT, lat));
@@ -843,8 +872,7 @@ export class GridRenderLayer {
                         const mercator = this.getMercatorCoordinate(lon, clampedLat);
                         
                         if (!isFinite(mercator.x) || !isFinite(mercator.y)) {
-                            console.warn(`[GridLayer] Invalid HRDPS Mercator coordinates: x=${mercator.x}, y=${mercator.y}`);
-                            continue;
+                                                        continue;
                         }
                         
                         // Texture coordinates - corrected for HRDPS orientation
@@ -854,8 +882,7 @@ export class GridRenderLayer {
                         vertices.push(mercator.x, mercator.y, tex_u, tex_v);
                         
                     } catch (error) {
-                        console.warn(`[GridLayer] HRDPS manual transformation error at ${row},${col}:`, error);
-                        continue;
+                                                continue;
                     }
                 }
             }
@@ -941,8 +968,7 @@ export class GridRenderLayer {
                         }
 
                         if (lon_raw > 0) {
-                            console.warn(`[GridLayer] Rejecting suspicious positive longitude: ${lon} at [${row},${col}]`);
-                            vertexGrid[row][col] = null;
+                                                        vertexGrid[row][col] = null;
                             continue;
                         }
                         
@@ -987,8 +1013,7 @@ export class GridRenderLayer {
             }
 
             if (vertices.length === 0) {
-                console.error(`[GridLayer] No valid vertices generated for polar stereographic model`);
-                return;
+                                return;
             }
             
             // Second pass: generate indices (this logic remains the same)
@@ -1080,8 +1105,7 @@ export class GridRenderLayer {
                         const [lon, lat] = proj4(projectionString, wgs84, [proj_x, proj_y]);
 
                         if (lon > 0) {
-                            console.warn(`[GridLayer] Rejecting suspicious positive longitude: ${lon} at [${row},${col}]`);
-                            vertexGrid[row][col] = null;
+                                                        vertexGrid[row][col] = null;
                             continue;
                         }
                         
@@ -1114,16 +1138,14 @@ export class GridRenderLayer {
                         validVertexCount++;
                         
                     } catch (error) {
-                        console.warn(`[GridLayer] Projection error at [${row},${col}] with coords [${proj_x}, ${proj_y}]:`, error);
-                        vertexGrid[row][col] = null;
+                                                vertexGrid[row][col] = null;
                         continue;
                     }
                 }
             }
 
             if (vertices.length === 0) {
-                console.error(`[GridLayer] No valid vertices generated for ${this.modelName}`);
-                return;
+                                return;
             }
             
             // Second pass: generate indices only for quads where all 4 vertices are valid
@@ -1153,8 +1175,7 @@ export class GridRenderLayer {
             
             // Check for potential dateline issues and log them
             if (validMaxLon - validMinLon > 180) {
-                console.warn(`[GridLayer] ${this.modelName} longitude span is ${(validMaxLon - validMinLon).toFixed(2)}° - this might indicate projection issues`);
-            }
+                            }
             
             const vertexData = new Float32Array(vertices);
             gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
@@ -1172,14 +1193,12 @@ export class GridRenderLayer {
             this.vertexCount = vertices.length / 4;
 
         } else {
-            console.error(`[GridLayer] Unsupported grid type: ${gridType}`);
-            return;
+                        return;
         }
     }
 
     updateDataTexture(data, encoding, nx, ny) {
         if (!this.gl || !data) {
-            console.warn('❌ updateDataTexture early exit - missing gl or data');
             return;
         }
         
@@ -1201,12 +1220,6 @@ export class GridRenderLayer {
         const expectedSize = nx * ny;
 
         if (data.length === 0 || data.length < expectedSize) {
-            console.warn('⚠️ Data array is empty or too small - NO TEXTURE WILL BE CREATED', {
-                dataLength: data.length,
-                expected: expectedSize,
-                nx: nx,
-                ny: ny
-            });
             return;
         }
 
@@ -1224,15 +1237,7 @@ export class GridRenderLayer {
         this.dataTexture = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, this.dataTexture);
 
-        try {
-            // FIX: Set pixel store alignment to 1 to handle widths not divisible by 4
-            gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
-            
-            gl.texImage2D(gl.TEXTURE_2D, 0, gl.LUMINANCE, nx, ny, 0, gl.LUMINANCE, gl.UNSIGNED_BYTE, dataArray);
-        } catch (error) {
-            console.error('❌ texImage2D failed:', error);
-            throw error;
-        }
+        this._uploadQuantizedGridTexture(this.dataTexture, nx, ny, dataArray);
         
         // Set texture parameters
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
@@ -1302,11 +1307,15 @@ export class GridRenderLayer {
     }
 
     render(gl, matrix) {
-        if (!this.dataTexture) {
-            console.log('⏭️ Skipping render - no texture available');
+        if (!this.dataTexture || !this.encoding) {
+            return;
+        }
+        if (!this.colormapTexture) {
+            return;
+        }
+        if (!this.program || !this.vertexBuffer || !this.indexBuffer) {
             return;
         }
-        if (!this.program || !this.encoding || !this.vertexBuffer || !this.indexBuffer) return;
         gl.useProgram(this.program);
 
         if (this.u_is_ptype) {
@@ -1340,30 +1349,40 @@ export class GridRenderLayer {
     
     onRemove() {
         if (!this.gl) return;
+        const gl = this.gl;
 
         if (this.program) {
-            this.gl.deleteProgram(this.program);
+            gl.deleteProgram(this.program);
             this.program = null;
         }
         if (this.vertexBuffer) {
-            this.gl.deleteBuffer(this.vertexBuffer);
+            gl.deleteBuffer(this.vertexBuffer);
             this.vertexBuffer = null;
         }
         if (this.indexBuffer) {
-            this.gl.deleteBuffer(this.indexBuffer);
+            gl.deleteBuffer(this.indexBuffer);
             this.indexBuffer = null;
         }
-        if (this.dataTexture) {
-            this.gl.deleteTexture(this.dataTexture);
-            this.dataTexture = null;
+
+        const gridTextures = new Set();
+        if (this.dataTexture) gridTextures.add(this.dataTexture);
+        if (this.preloadedTextures) {
+            for (const { tex } of this.preloadedTextures.values()) {
+                if (tex) gridTextures.add(tex);
+            }
+            this.preloadedTextures.clear();
         }
+        for (const tex of gridTextures) {
+            gl.deleteTexture(tex);
+        }
+        this.dataTexture = null;
+
         if (this.colormapTexture) {
-            this.gl.deleteTexture(this.colormapTexture);
+            gl.deleteTexture(this.colormapTexture);
             this.colormapTexture = null;
         }
-        
+
         this.map = null;
         this.gl = null;
-        this.clearPreloadedTextures();
     }
 }

package/src/MapManager.js

@@ -41,13 +41,28 @@ function isObject(item) {
 const BASE_STYLE_URL = 'mapbox://styles/aguacerowx/cmfvox8mq004u01qm5nlg7qkt';
 
 export class MapManager extends EventEmitter {
+    /**
+     * @param {string} containerId - DOM element id for the Mapbox map container.
+     * @param {object} options
+     * @param {string} [options.accessToken] - Mapbox access token (required unless `mapboxToken` is set).
+     * @param {string} [options.mapboxToken] - Alias for `accessToken` (e.g. React Native parity).
+     * @param {object} [options.mapOptions] - Passed through to `mapboxgl.Map` (after defaults); `style` here is used unless a valid custom style + anchor pair is set.
+     * @param {object} [options.customStyles] - Per-theme style overrides merged into {@link THEME_CONFIGS}.
+     * @param {'light'|'dark'} [options.defaultTheme]
+     * @param {'light'|'dark'} [options.theme] - Alias for `defaultTheme`.
+     * @param {string} [options.styleUrl] - Custom Mapbox style URL (alias: `styleURL`).
+     * @param {string} [options.styleURL] - Same as `styleUrl`.
+     * @param {string} [options.weatherBeforeLayerId] - Style layer id to insert Aguacero layers below (alias: `belowID`).
+     * @param {string} [options.belowID] - Same as `weatherBeforeLayerId`. With `styleUrl`/`styleURL`, required for correct stacking; default Aguacero style uses `AML_-_terrain` in {@link WeatherLayerManager} when omitted.
+     */
     constructor(containerId, options = {}) {
         super();
-        if (!containerId || !options.accessToken) {
+        const accessToken = options.accessToken || options.mapboxToken;
+        if (!containerId || !accessToken) {
             throw new Error('A container ID and a Mapbox access token are required.');
         }
 
-        mapboxgl.accessToken = options.accessToken;
+        mapboxgl.accessToken = accessToken;
 
         // --- THE FIX IS HERE ---
 
@@ -57,15 +72,12 @@ export class MapManager extends EventEmitter {
 
         // 2. If developer provides custom styles, merge them into the defaults
         if (options.customStyles) {
-            console.log('[MapManager] Custom styles provided. Merging...');
             if (options.customStyles.light) {
                 lightTheme = deepMerge(lightTheme, options.customStyles.light);
             }
             if (options.customStyles.dark) {
                 darkTheme = deepMerge(darkTheme, options.customStyles.dark);
             }
-            // Log to confirm the merge was successful
-            console.log('[MapManager] Final merged dark theme:', darkTheme);
         }
 
         // 3. Store the final, potentially merged, themes
@@ -76,22 +88,47 @@ export class MapManager extends EventEmitter {
         
         // --- END OF FIX ---
 
-        const defaultThemeName = options.defaultTheme || 'light';
+        const defaultThemeName = options.theme || options.defaultTheme || 'light';
         this.currentCustomizations = this.themes[defaultThemeName];
         this.currentThemeName = defaultThemeName;
 
         this.weatherLayerManagers = new Map();
-        
+
+        const mapOptions = options.mapOptions || {};
+        let initialStyle = mapOptions.style !== undefined ? mapOptions.style : BASE_STYLE_URL;
+        /** @type {string | null} */
+        let weatherBeforeLayerId = null;
+
+        const customStyleUrl = options.styleURL || options.styleUrl;
+        const customBeforeId = options.belowID || options.weatherBeforeLayerId;
+        if (customStyleUrl) {
+            if (customBeforeId && String(customBeforeId).trim()) {
+                initialStyle = customStyleUrl;
+                weatherBeforeLayerId = String(customBeforeId).trim();
+            } else {
+                console.warn(
+                    '[MapManager] A custom style (`styleUrl` / `styleURL`) was provided without a non-empty `weatherBeforeLayerId` / `belowID`. ' +
+                        'Weather layers need a style layer id to insert below; keeping the default Aguacero style.'
+                );
+                if (mapOptions.style === undefined) {
+                    initialStyle = BASE_STYLE_URL;
+                }
+            }
+        }
+
+        this.weatherBeforeLayerId = weatherBeforeLayerId;
+
         this.map = new mapboxgl.Map({
             container: containerId,
-            style: BASE_STYLE_URL,
             center: [-98, 39],
             zoom: 3.5,
-            ...options.mapOptions
+            ...mapOptions,
+            style: initialStyle,
         });
+
+        this.map.__aguaceroMapsgl = { weatherBeforeLayerId };
         
         this.map.on('load', () => {
-             console.log("[MapManager] Map loaded. Applying initial theme:", defaultThemeName);
              applyStyleCustomizations(this.map, this.currentCustomizations);
              this.emit('style:applied', {
                  themeName: this.currentThemeName,
@@ -103,7 +140,6 @@ export class MapManager extends EventEmitter {
     // The rest of the methods (setTheme, setLabelGroupVisibility, etc.) are correct and remain unchanged...
     setTheme(themeName) {
         if (!this.themes[themeName]) {
-            console.error(`[MapManager] Theme "${themeName}" does not exist.`);
             return;
         }
         
@@ -141,7 +177,6 @@ export class MapManager extends EventEmitter {
         for (let i = 0; i < parts.length - 1; i++) {
             current = current[parts[i]];
             if (!current) {
-                 console.error(`Invalid label group key: ${groupKey}`);
                  return;
             }
         }
@@ -152,9 +187,6 @@ export class MapManager extends EventEmitter {
         
         if (layerId && this.map.getLayer(layerId)) {
             this.map.setLayoutProperty(layerId, 'visibility', visible ? 'visible' : 'none');
-            console.log(`[MapManager] Set visibility for ${layerId} to ${visible}`);
-        } else {
-             console.warn(`[MapManager] Could not find layer for label group key: ${groupKey} (mapped to ${mapKey})`);
         }
     }