@aguacerowx/mapsgl 0.0.29 → 0.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aguacerowx/mapsgl",
-  "version": "0.0.29",
+  "version": "0.0.32",
   "private": false,
   "publishConfig": {
     "access": "public"

package/src/WeatherLayerManager.js

@@ -69,26 +69,14 @@ export class WeatherLayerManager extends EventEmitter {
         const runKey = `${state.model}-${state.date}-${state.run}-${state.variable}`;
         const existingRunKey = this.shaderLayer?.runKey ?? 'none';
 
-        console.log(`[WLM._handleStateChange]`, {
-            runKey, timeKey,
-            existingRunKey,
-            currentLoadedTimeKey: this.currentLoadedTimeKey,
-            shaderLayerExists: !!this.shaderLayer,
-            decision: !this.shaderLayer || existingRunKey !== runKey
-                ? 'REBUILD'
-                : this.currentLoadedTimeKey !== timeKey
-                    ? 'UPDATE_DATA'
-                    : 'STYLE_ONLY'
-        });
-
         if (!this.shaderLayer || this.shaderLayer.runKey !== runKey) {
-            console.log(`[WLM._handleStateChange] → dispatching _rebuildLayerAndPreload (runKey changed: "${existingRunKey}" → "${runKey}")`);
+            //console.log(`[WLM._handleStateChange] → dispatching _rebuildLayerAndPreload (runKey changed: "${existingRunKey}" → "${runKey}")`);
             this._rebuildLayerAndPreload(state);
         } else if (this.currentLoadedTimeKey !== timeKey) {
-            console.log(`[WLM._handleStateChange] → dispatching _updateLayerData (timeKey changed: ${this.currentLoadedTimeKey} → ${timeKey})`);
+            //console.log(`[WLM._handleStateChange] → dispatching _updateLayerData (timeKey changed: ${this.currentLoadedTimeKey} → ${timeKey})`);
             this._updateLayerData(state);
         } else {
-            console.log(`[WLM._handleStateChange] → style/opacity update only`);
+            //console.log(`[WLM._handleStateChange] → style/opacity update only`);
         }
 
         if (this.shaderLayer) {
@@ -140,30 +128,30 @@ export class WeatherLayerManager extends EventEmitter {
         }
 
         const timeKey = state.isMRMS ? state.mrmsTimestamp : state.forecastHour;
-        console.log(`[WLM._updateLayerDataWithToken] token=${requestToken} timeKey=${timeKey}`);
+        //console.log(`[WLM._updateLayerDataWithToken] token=${requestToken} timeKey=${timeKey}`);
 
         if (this.shaderLayer.switchToPreloadedTexture(timeKey)) {
             this.currentLoadedTimeKey = timeKey;
-            console.log(`[WLM._updateLayerDataWithToken] token=${requestToken} — FAST PATH: preloaded texture found for timeKey=${timeKey}, swapped instantly`);
+            //console.log(`[WLM._updateLayerDataWithToken] token=${requestToken} — FAST PATH: preloaded texture found for timeKey=${timeKey}, swapped instantly`);
             this.map.triggerRepaint();
             return;
         }
 
-        console.log(`[WLM._updateLayerDataWithToken] token=${requestToken} — SLOW PATH: no preloaded texture for timeKey=${timeKey}, fetching...`);
+        //console.log(`[WLM._updateLayerDataWithToken] token=${requestToken} — SLOW PATH: no preloaded texture for timeKey=${timeKey}, fetching...`);
         const fetchStart = performance.now();
         try {
             const grid = await this.core._loadGridData(state);
             const fetchMs = (performance.now() - fetchStart).toFixed(1);
 
             if (requestToken !== this.latestDataRequestToken) {
-                console.log(`[WLM._updateLayerDataWithToken] token=${requestToken} — STALE after fetch (latestToken=${this.latestDataRequestToken}), discarding (${fetchMs}ms)`);
+                //console.log(`[WLM._updateLayerDataWithToken] token=${requestToken} — STALE after fetch (latestToken=${this.latestDataRequestToken}), discarding (${fetchMs}ms)`);
                 return;
             }
 
             if (grid && grid.data) {
                 const gridModel = state.isMRMS ? 'mrms' : state.model;
                 const { gridDef } = this.core._getGridCornersAndDef(gridModel);
-                console.log(`[WLM._updateLayerDataWithToken] token=${requestToken} — grid received in ${fetchMs}ms, storing+switching texture for timeKey=${timeKey}`);
+                //console.log(`[WLM._updateLayerDataWithToken] token=${requestToken} — grid received in ${fetchMs}ms, storing+switching texture for timeKey=${timeKey}`);
 
                 this.shaderLayer.storePreloadedTexture(
                     timeKey, grid.data, grid.encoding,
@@ -189,28 +177,17 @@ export class WeatherLayerManager extends EventEmitter {
 
     async _rebuildLayerAndPreload(state) {
         const rebuildId = ++this.currentRebuildId;
-        console.log(`[WLM._rebuildLayerAndPreload] START rebuildId=${rebuildId}`, {
-            model: state.model, variable: state.variable, date: state.date,
-            run: state.run, forecastHour: state.forecastHour,
-            isMRMS: state.isMRMS, mrmsTimestamp: state.mrmsTimestamp
-        });
 
         this.core.cancelAllRequests();
-        console.log(`[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — cancelled all pending requests`);
 
         if (this.shaderLayer) {
-            console.log(`[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — removing existing shaderLayer id=${this.shaderLayer.id} runKey=${this.shaderLayer.runKey}`);
             this.map.removeLayer(this.shaderLayer.id);
             this.shaderLayer = null;
         }
         this.currentLoadedTimeKey = null;
 
-        if (!state.variable) {
-            console.warn(`[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — no variable set, aborting rebuild`);
-            return;
-        }
+        if (!state.variable) return;
 
-        // --- FIX: Correct an invalid forecastHour before building the layer ---
         if (
             !state.isMRMS &&
             state.forecastHour === 0 &&
@@ -220,50 +197,32 @@ export class WeatherLayerManager extends EventEmitter {
             const availableHours =
                 this.core.modelStatus?.[state.model]?.[state.date]?.[state.run] || [];
             const firstValidHour = availableHours.find(h => h !== 0);
-            console.warn(
-                `[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — ptypeRefl/HRRR hour-0 correction triggered.`,
-                { availableHours, firstValidHour: firstValidHour ?? 'NOT FOUND — will proceed with 0' }
-            );
             if (firstValidHour !== undefined) {
                 state = { ...state, forecastHour: firstValidHour };
-                // CRITICAL: Mutate core.state directly instead of calling core.setState().
-                // core.setState() emits state:change, which triggers _handleStateChange,
-                // which spawns a second concurrent rebuild — causing a duplicate addLayer
-                // crash and a gl=null texture upload on the layer that wins the race.
                 this.core.state.forecastHour = firstValidHour;
-                console.log(`[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — corrected forecastHour to ${firstValidHour} (silent, no state:change emitted)`);
+            } else {
+                // Run exists but has no valid hours yet — bail out entirely
+                console.warn(`[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — ptypeRefl/HRRR: no valid hours in new run yet, aborting rebuild`);
+                return;
             }
         }
-        // --- END FIX ---
 
-        // Guard: if a newer rebuild has already started, bail before touching the map
-        if (rebuildId !== this.currentRebuildId) {
-            console.log(`[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — STALE before addLayer (currentRebuildId=${this.currentRebuildId}), aborting`);
-            return;
-        }
+        if (rebuildId !== this.currentRebuildId) return;
 
         const runKey = `${state.model}-${state.date}-${state.run}-${state.variable}`;
-        console.log(`[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — creating shaderLayer runKey=${runKey}, forecastHour=${state.forecastHour}`);
 
         this.shaderLayer = new GridRenderLayer(this.layerId);
         this.shaderLayer.runKey = runKey;
         this.map.addLayer(this.shaderLayer, 'AML_-_terrain');
         this._updateLayerStyle(state);
 
-        console.log(`[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — fetching grid data...`);
-        const fetchStart = performance.now();
         const grid = await this.core._loadGridData(state);
-        const fetchMs = (performance.now() - fetchStart).toFixed(1);
 
-        if (rebuildId !== this.currentRebuildId) {
-            console.log(`[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — STALE after grid fetch (currentRebuildId=${this.currentRebuildId}), discarding result (fetch took ${fetchMs}ms)`);
-            return;
-        }
+        if (rebuildId !== this.currentRebuildId) return;
 
         if (grid && grid.data) {
             const gridModel = state.isMRMS ? 'mrms' : state.model;
             const { gridDef } = this.core._getGridCornersAndDef(gridModel);
-            console.log(`[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — grid data received in ${fetchMs}ms, uploading texture. nx=${gridDef.grid_params.nx} ny=${gridDef.grid_params.ny} dataLength=${grid.data.length}`);
 
             this.shaderLayer.updateDataTexture(
                 grid.data, grid.encoding,
@@ -272,35 +231,25 @@ export class WeatherLayerManager extends EventEmitter {
 
             this.currentLoadedTimeKey = state.isMRMS ? state.mrmsTimestamp : state.forecastHour;
             this.latestDataRequestToken = this.currentRebuildId;
-            console.log(`[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — texture uploaded, currentLoadedTimeKey=${this.currentLoadedTimeKey}, triggering repaint`);
             this.map.triggerRepaint();
-        } else {
-            console.error(
-                `[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — grid fetch returned null/empty after ${fetchMs}ms.`,
-                { model: state.model, variable: state.variable, date: state.date, run: state.run, forecastHour: state.forecastHour, isMRMS: state.isMRMS },
-                '← THIS IS WHY THE MAP IS BLANK'
-            );
         }
 
         if (rebuildId === this.currentRebuildId) {
-            console.log(`[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — starting preload for all time steps`);
             this._preloadAllTimeSteps(state);
-        } else {
-            console.log(`[WLM._rebuildLayerAndPreload] rebuildId=${rebuildId} — skipping preload, rebuild superseded by rebuildId=${this.currentRebuildId}`);
         }
     }
     
     _preloadAllTimeSteps(state) {
         const timeSteps = state.isMRMS ? state.availableTimestamps : state.availableHours;
         if (!timeSteps || timeSteps.length <= 1) {
-            console.log(`[WLM._preloadAllTimeSteps] skipping — only ${timeSteps?.length ?? 0} time steps available`);
+            //console.log(`[WLM._preloadAllTimeSteps] skipping — only ${timeSteps?.length ?? 0} time steps available`);
             return;
         }
 
         const currentFrameTime = state.isMRMS ? state.mrmsTimestamp : state.forecastHour;
         const stepsToPreload = timeSteps.filter(t => t !== currentFrameTime);
         const capturedRebuildId = this.currentRebuildId;
-        console.log(`[WLM._preloadAllTimeSteps] preloading ${stepsToPreload.length} frames (skipping currentFrameTime=${currentFrameTime}), capturedRebuildId=${capturedRebuildId}`);
+        //console.log(`[WLM._preloadAllTimeSteps] preloading ${stepsToPreload.length} frames (skipping currentFrameTime=${currentFrameTime}), capturedRebuildId=${capturedRebuildId}`);
 
         const gridModel = state.isMRMS ? 'mrms' : state.model;
         const { gridDef } = this.core._getGridCornersAndDef(gridModel);
@@ -321,7 +270,7 @@ export class WeatherLayerManager extends EventEmitter {
                             gridDef.grid_params.nx, gridDef.grid_params.ny
                         );
                         completed++;
-                        console.log(`[WLM._preloadAllTimeSteps] stored texture for time=${time} (${completed}/${stepsToPreload.length} done, ${failed} failed)`);
+                        //console.log(`[WLM._preloadAllTimeSteps] stored texture for time=${time} (${completed}/${stepsToPreload.length} done, ${failed} failed)`);
                     } else if (!grid?.data) {
                         failed++;
                         console.warn(`[WLM._preloadAllTimeSteps] null grid for time=${time} — skipping texture store (${completed}/${stepsToPreload.length} done, ${failed} failed)`);
@@ -357,10 +306,10 @@ export class WeatherLayerManager extends EventEmitter {
         let dataRange;
         if (state.variable === 'ptypeRefl' || state.variable === 'ptypeRate') {
             if (state.isMRMS) {
-                console.log('🔧 Using MRMS ptype data range: 5-380');
+                //console.log('🔧 Using MRMS ptype data range: 5-380');
                 dataRange = [5, 380];
             } else {
-                console.log('🔧 Using Model ptype data range: 5-380');
+                //console.log('🔧 Using Model ptype data range: 5-380');
                 dataRange = [5, 380]; // Models also use the full colormap range
             }
         } else {
@@ -432,7 +381,7 @@ export class WeatherLayerManager extends EventEmitter {
      * @returns {Promise<void>}
      */
     async refreshData() {
-        console.log('[WeatherLayerManager] Manual data refresh triggered.');
+        //console.log('[WeatherLayerManager] Manual data refresh triggered.');
         // This just calls the internal logic we already built.
         await this._checkForUpdates();
     }
@@ -480,8 +429,14 @@ export class WeatherLayerManager extends EventEmitter {
                 this.emit('data:updated', { type: 'mrms', variable: currentVariable, newTimestamps: newTimestampsToPreload });
             }
         } else {
+            const previousStatus = this.core.modelStatus;
             const modelStatus = await this.core.fetchModelStatus(true);
-            this.core._emitStateChange();
+            
+            // Only emit if the status actually changed
+            const statusChanged = JSON.stringify(previousStatus) !== JSON.stringify(modelStatus);
+            if (statusChanged) {
+                this.core._emitStateChange();
+            }
 
             const latestRun = findLatestModelRun(modelStatus, currentModel);
             if (!latestRun) return;
@@ -525,6 +480,6 @@ export class WeatherLayerManager extends EventEmitter {
         // 4. Clear any remaining internal state
         this.currentLoadedTimeKey = null;
         
-        console.log(`WeatherLayerManager with id "${this.layerId}" has been destroyed.`);
+        //console.log(`WeatherLayerManager with id "${this.layerId}" has been destroyed.`);
     }
 }