@aguacerowx/react-native 0.0.35 → 0.0.37

package/src/WeatherLayerManager.js

@@ -1,11 +1,11 @@
 // packages/react-native/src/WeatherLayerManager.js
 
-import React, { useState, useRef, useContext, useEffect, forwardRef, useImperativeHandle, useMemo } from 'react';
-import { AguaceroCore, getUnitConversionFunction, DICTIONARIES } from '@aguacerowx/javascript-sdk';
+import { AguaceroCore, DICTIONARIES, getUnitConversionFunction } from '@aguacerowx/javascript-sdk';
+import { fromByteArray } from 'base64-js';
+import React, { forwardRef, useContext, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react';
+import { NativeModules, Platform } from 'react-native';
 import { AguaceroContext } from './AguaceroContext';
 import { GridRenderLayer } from './GridRenderLayer';
-import { fromByteArray } from 'base64-js';
-import { Platform, NativeModules } from 'react-native';
 import { mapRegistry } from './MapRegistry';
 
 function findLatestModelRun(modelsData, modelName) {
@@ -67,27 +67,27 @@ const _generateColormapBytes = (colormap) => {
     return data;
 };
 
-AguaceroCore.prototype.setMapCenter = function(center) {
+AguaceroCore.prototype.setMapCenter = function (center) {
     this.emit('map:move', center);
 };
 
 export const WeatherLayerManager = forwardRef((props, ref) => {
-    const { 
-        inspectorEnabled, 
-        onInspect, 
-        apiKey, 
-        customColormaps, 
-        initialMode, 
+    const {
+        inspectorEnabled,
+        onInspect,
+        apiKey,
+        customColormaps,
+        initialMode,
         initialVariable,
-        autoRefresh,        
-        autoRefreshInterval,  
+        autoRefresh,
+        autoRefreshInterval,
         initialModel,
-        ...restProps 
+        ...restProps
     } = props;
     const context = useContext(AguaceroContext);
-    
+
     // Create the core here instead of getting it from context
-    const core = useMemo(() => new AguaceroCore({ 
+    const core = useMemo(() => new AguaceroCore({
         apiKey: apiKey,
         customColormaps: customColormaps,
         // ADD: Pass layerOptions to the core's constructor
@@ -97,27 +97,27 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             model: initialModel
         }
     }), [apiKey]);
-    
+
     const gridLayerRef = useRef(null);
     const currentGridDataRef = useRef(null);
     const autoRefreshIntervalId = useRef(null);
-    
+
     // Cache for preloaded grid data - stores the processed data ready for GPU upload
     const preloadedDataCache = useRef(new Map());
-    
+
     // Store geometry and colormap that don't change with forecast hour
     const cachedGeometry = useRef(null);
     const cachedColormap = useRef(null);
     const cachedDataRange = useRef([0, 1]);
-    
+
     // Track if we've done the initial load
     const hasInitialLoad = useRef(false);
     const hasPreloadedRef = useRef(false);
-    
+
     // Track the last state we processed to avoid redundant updates
     const lastProcessedState = useRef(null);
     const previousStateRef = useRef(null);
-    
+
     const [renderProps, setRenderProps] = useState({
         opacity: 1,
         dataRange: [0, 1]
@@ -223,11 +223,11 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             }
             const colormapBytes = _generateColormapBytes(finalColormap);
             const colormapAsBase64 = fromByteArray(colormapBytes);
-            
+
             gridLayerRef.current.updateColormapTexture(colormapAsBase64);
             cachedColormap.current = { key: `${variable}-${units}` };
             cachedDataRange.current = dataRange;
-            
+
             setRenderProps({ opacity: state.opacity, dataRange: dataRange });
             hasInitialLoad.current = true;
         }
@@ -259,7 +259,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
 
         // Load the current frame FIRST and WAIT for it before continuing
         const currentCacheKey = isMRMS ? `mrms-${currentFrame}-${variable}` : `${model}-${date}-${run}-${currentFrame}-${variable}`;
-        
+
         if (!preloadedDataCache.current.has(currentCacheKey)) {
             let resourcePath;
             if (isMRMS) {
@@ -277,13 +277,13 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
 
             try {
                 const result = await WeatherFrameProcessorModule.processFrame(options);
-                
+
                 if (!result || !result.filePath) {
                     return;
                 }
-                
+
                 const { baseUnit } = core._getColormapForVariable(variable);
-                
+
                 const toUnit = core._getTargetUnit(baseUnit, units);
 
                 const fieldInfo = DICTIONARIES?.fld?.[variable] || {};
@@ -315,7 +315,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                         dataOffset = convertedOffset;
                     }
                 }
-                
+
                 if (baseUnit !== toUnit) {
                     const conversionFunc = getUnitConversionFunction(baseUnit, toUnit);
                     if (conversionFunc) {
@@ -333,21 +333,21 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                             convertedScale = convertedOffsetPlusScale - convertedOffset;
                         }
                     }
-                } 
-                
+                }
+
                 const frameData = {
                     filePath: result.filePath,
                     nx, ny,
                     scale: convertedScale,
                     offset: convertedOffset,
                     missing: result.missing,
-                    corners, 
+                    corners,
                     gridDef,
                     scaleType: result.scaleType,
                     originalScale: result.scale,
                     originalOffset: result.offset
                 };
-                
+
                 preloadedDataCache.current.set(currentCacheKey, frameData);
 
                 // Update the GPU with the current frame
@@ -402,19 +402,19 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                         console.warn(`⚠️ [preloadAllFramesToDisk] Failed frame ${frame}: No filePath`);
                         return;
                     }
-                    
+
                     // ADD: Same two-step conversion as the current frame
                     const { baseUnit } = core._getColormapForVariable(variable);
                     const toUnit = core._getTargetUnit(baseUnit, units);
                     const fieldInfo = DICTIONARIES?.fld?.[variable] || {};
                     const serverDataUnit = fieldInfo.defaultUnit || baseUnit;
-                    
+
                     let dataScale = result.scale;
                     let dataOffset = result.offset;
-                    
+
                     let convertedScale = dataScale;
                     let convertedOffset = dataOffset;
-                    
+
                     // Step 1: Convert from server unit to colormap base unit
                     if (serverDataUnit !== baseUnit) {
                         const conversionFunc = getUnitConversionFunction(serverDataUnit, baseUnit);
@@ -436,7 +436,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                             dataOffset = convertedOffset;
                         }
                     }
-                    
+
                     // Step 2: Convert from colormap base unit to target display unit
                     if (baseUnit !== toUnit) {
                         const conversionFunc = getUnitConversionFunction(baseUnit, toUnit);
@@ -456,27 +456,27 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                             }
                         }
                     }
-                    
+
                     const frameData = {
                         filePath: result.filePath,
                         nx, ny,
                         scale: convertedScale,
                         offset: convertedOffset,
                         missing: result.missing,
-                        corners, 
+                        corners,
                         gridDef,
                         scaleType: result.scaleType,
                         originalScale: result.scale,
                         originalOffset: result.offset
                     };
-                    
+
                     preloadedDataCache.current.set(cacheKey, frameData);
 
                     if (Platform.OS === 'ios' && gridLayerRef.current.primeGpuCache) {
                         const frameInfoForGpu = {
                             [cacheKey]: {
-                                filePath: frameData.filePath, 
-                                nx: frameData.nx, 
+                                filePath: frameData.filePath,
+                                nx: frameData.nx,
                                 ny: frameData.ny,
                                 scale: frameData.scale,
                                 offset: frameData.offset,
@@ -514,7 +514,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
 
     const updateGPUWithCachedData = (state) => {
         const { model, date, run, forecastHour, variable, units, isMRMS, mrmsTimestamp } = state;
-        
+
         const cacheKey = isMRMS
             ? `mrms-${mrmsTimestamp}-${variable}`
             : `${model}-${date}-${run}-${forecastHour}-${variable}`;
@@ -522,7 +522,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
         if (Platform.OS === 'ios' && gridLayerRef.current.setActiveFrame) {
             // Get the cached data BEFORE calling setActiveFrame
             const cachedData = preloadedDataCache.current.get(cacheKey);
-            
+
             if (cachedData) {
                 currentGridDataRef.current = {
                     nx: cachedData.nx,
@@ -536,28 +536,30 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                     scaleType: cachedData.scaleType
                 };
             }
-            
-            // Now call setActiveFrame (which will async update the native cache)
+
+            if (__DEV__) {
+                console.log(`[WeatherLayerManager] setActiveFrame: ${cacheKey}`);
+            }
             gridLayerRef.current.setActiveFrame(cacheKey);
             return true;
         }
 
         const cachedData = preloadedDataCache.current.get(cacheKey);
-        
+
         if (!cachedData) {
             return false;
         }
-        
+
         if (!gridLayerRef.current) {
             console.warn(`⚠️ [updateGPUWithCachedData] GridLayer ref not available`); // CHANGED
             return false;
         }
-        
+
         if (!cachedGeometry.current || cachedGeometry.current.model !== (isMRMS ? 'mrms' : model) || cachedGeometry.current.variable !== variable) {
             gridLayerRef.current.updateGeometry(cachedData.corners, cachedData.gridDef);
             cachedGeometry.current = { model: (isMRMS ? 'mrms' : model), variable };
-        } 
-        
+        }
+
         const colormapKey = `${variable}-${units}`;
         if (!cachedColormap.current || cachedColormap.current.key !== colormapKey) {
             const { colormap, baseUnit } = core._getColormapForVariable(variable);
@@ -575,14 +577,14 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             }
             const colormapBytes = _generateColormapBytes(finalColormap);
             const colormapAsBase64 = fromByteArray(colormapBytes);
-            
+
             gridLayerRef.current.updateColormapTexture(colormapAsBase64);
             cachedColormap.current = { key: colormapKey };
             cachedDataRange.current = dataRange;
-            
+
             setRenderProps(prev => ({ ...prev, dataRange }));
-        } 
-        
+        }
+
         if (cachedData.filePath) {
             gridLayerRef.current.updateDataTextureFromFile(
                 cachedData.filePath,
@@ -590,7 +592,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 cachedData.scale, cachedData.offset, cachedData.missing,
                 cachedData.scaleType
             );
-            
+
             // ADD THIS: Update inspector cache for file-based data too
             currentGridDataRef.current = {
                 nx: cachedData.nx,
@@ -609,15 +611,15 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 cachedData.scale, cachedData.offset, cachedData.missing,
                 cachedData.scaleType
             );
-            
+
             // Update the inspector cache when using dataAsBase64
             const binaryString = atob(cachedData.dataAsBase64);
             const uint8Array = new Uint8Array(binaryString.length);
-            
+
             for (let i = 0; i < binaryString.length; i++) {
                 uint8Array[i] = binaryString.charCodeAt(i);
             }
-            
+
             currentGridDataRef.current = {
                 data: uint8Array,
                 nx: cachedData.nx,
@@ -634,11 +636,11 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             console.error('❌ [updateGPUWithCachedData] Cached data keys:', Object.keys(cachedData));
             return false;
         }
-        
+
         // Update inspector parameters for file-based data too
         if (gridLayerRef.current && gridLayerRef.current.updateDataParameters) {
             gridLayerRef.current.updateDataParameters(cachedData.scale, cachedData.offset, cachedData.missing);
-        } 
+        }
         return true;
     };
 
@@ -660,16 +662,16 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             console.warn('🔍 [Inspector] Core not available');
             return null;
         }
-        
+
         // ADD THIS: Check if we have valid data before attempting inspection
         if (!currentGridDataRef.current) {
             return null;
         }
-        
+
         try {
             const gridIndices = core._getGridIndexFromLngLat(lng, lat);
             if (!gridIndices) return null;
-            
+
             const { i, j } = gridIndices;
 
             const value = await InspectorModule.getValueAtGridIndex(i, j);
@@ -677,12 +679,12 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             if (value === null) {
                 return null;
             }
-            
+
             const { colormap, baseUnit } = core._getColormapForVariable(core.state.variable);
             const displayUnit = core._getTargetUnit(baseUnit, core.state.units);
             const finalColormap = core._convertColormapUnits(colormap, baseUnit, displayUnit);
             const minThreshold = finalColormap[0];
-            
+
             if (value < minThreshold) {
                 return null;
             }
@@ -691,12 +693,12 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             if (value < minThreshold) {
                 return null;
             }
-            
+
             // Also check if value is NaN or effectively missing
             if (!isFinite(value)) {
                 return null;
             }
-            
+
             return {
                 value: value,
                 unit: displayUnit,
@@ -736,7 +738,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 newTimestampsToPreload.forEach(frame => {
                     const cacheKey = `mrms-${frame}-${currentVariable}`;
                     if (preloadedDataCache.current.has(cacheKey)) return;
-                    
+
                     const frameDate = new Date(frame * 1000);
                     const y = frameDate.getUTCFullYear(), m = (frameDate.getUTCMonth() + 1).toString().padStart(2, '0'), d = frameDate.getUTCDate().toString().padStart(2, '0');
                     const resourcePath = `/grids/mrms/${y}${m}${d}/${frame}/0/${currentVariable}/0`;
@@ -752,7 +754,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                             }
                         }).catch(error => console.warn(`[Auto-Refresh] Failed to preload frame ${frame}:`, error));
                 });
-                
+
                 const newTimestampsSet = new Set(newTimestamps);
                 oldTimestamps.forEach(oldTs => {
                     if (!newTimestampsSet.has(oldTs)) {
@@ -776,31 +778,29 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             return;
         }
 
-        const handleStateChange = async (newState) => {
-            props.onStateChange?.(newState);
-
+        const handleStateChange = (newState) => {
             if (!previousStateRef.current) {
                 previousStateRef.current = core.state;
-            } 
+            }
 
             const variableChanged = !previousStateRef.current || newState.variable !== previousStateRef.current.variable;
 
             if (variableChanged && gridLayerRef.current?.setVariable) {
                 gridLayerRef.current.setVariable(newState.variable);
             }
-            
+
             const stateKey = `${newState.model}-${newState.variable}-${newState.date}-${newState.run}-${newState.forecastHour}-${newState.units}-${newState.mrmsTimestamp}`;
 
-            const isOpacityOnlyChange = 
+            const isOpacityOnlyChange =
                 hasInitialLoad.current &&
-                newState.opacity !== renderProps.opacity && 
+                newState.opacity !== renderProps.opacity &&
                 newState.variable === previousStateRef.current?.variable &&
                 newState.forecastHour === previousStateRef.current?.forecastHour &&
                 newState.mrmsTimestamp === previousStateRef.current?.mrmsTimestamp &&
                 newState.model === previousStateRef.current?.model &&
                 newState.units === previousStateRef.current?.units;
 
-            const isPlayStateOnlyChange = 
+            const isPlayStateOnlyChange =
                 hasInitialLoad.current &&
                 newState.isPlaying !== previousStateRef.current?.isPlaying &&
                 newState.variable === previousStateRef.current?.variable &&
@@ -814,11 +814,11 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 previousStateRef.current = newState;
                 return;
             }
-            
+
             if (!isOpacityOnlyChange && !isPlayStateOnlyChange) {
                 lastProcessedState.current = stateKey;
             }
-            
+
             if (isOpacityOnlyChange) {
                 setRenderProps(prev => ({ ...prev, opacity: newState.opacity }));
                 previousStateRef.current = newState;
@@ -830,7 +830,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 return;
             }
 
-            const isUnitsOnlyChange = 
+            const isUnitsOnlyChange =
                 hasInitialLoad.current &&
                 newState.model === previousStateRef.current.model &&
                 newState.isMRMS === previousStateRef.current.isMRMS &&
@@ -843,21 +843,21 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
 
             if (isUnitsOnlyChange) {
                 const { variable, units, isMRMS, mrmsTimestamp, model, date, run, forecastHour } = newState;
-                const oldCacheKey = isMRMS 
+                const oldCacheKey = isMRMS
                     ? `mrms-${mrmsTimestamp}-${variable}`
                     : `${model}-${date}-${run}-${forecastHour}-${variable}`;
-                
+
                 const cachedData = preloadedDataCache.current.get(oldCacheKey);
-                
+
                 if (cachedData && cachedData.originalScale !== undefined && cachedData.originalOffset !== undefined) {
                     const { baseUnit } = core._getColormapForVariable(variable);
                     const toUnit = core._getTargetUnit(baseUnit, units);
                     const fieldInfo = DICTIONARIES?.fld?.[variable] || {};
                     const serverDataUnit = fieldInfo.defaultUnit || baseUnit;
-                    
+
                     let dataScale = cachedData.originalScale;
                     let dataOffset = cachedData.originalOffset;
-                    
+
                     if (serverDataUnit !== baseUnit) {
                         const conversionFunc = getUnitConversionFunction(serverDataUnit, baseUnit);
                         if (conversionFunc) {
@@ -878,7 +878,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                             }
                         }
                     }
-                    
+
                     if (baseUnit !== toUnit) {
                         const conversionFunc = getUnitConversionFunction(baseUnit, toUnit);
                         if (conversionFunc) {
@@ -898,19 +898,19 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                                 dataOffset = convertedOffset;
                             }
                         }
-                    } 
-                    
+                    }
+
                     const { colormap } = core._getColormapForVariable(variable);
                     const finalColormap = core._convertColormapUnits(colormap, baseUnit, toUnit);
                     let dataRange = (variable === 'ptypeRefl' || variable === 'ptypeRate') ? [5, 380] : [finalColormap[0], finalColormap[finalColormap.length - 2]];
                     const colormapBytes = _generateColormapBytes(finalColormap);
                     const colormapAsBase64 = fromByteArray(colormapBytes);
-                    
+
                     gridLayerRef.current.updateColormapTexture(colormapAsBase64);
                     cachedColormap.current = { key: `${variable}-${units}` };
                     cachedDataRange.current = dataRange;
                     setRenderProps(prev => ({ ...prev, dataRange, opacity: newState.opacity }));
-                    
+
                     if (gridLayerRef.current && gridLayerRef.current.updateDataParameters) {
                         const scaleTypeValue = cachedData.scaleType === 'sqrt' ? 1 : 0;
                         gridLayerRef.current.updateDataParameters(dataScale, dataOffset, cachedData.missing, scaleTypeValue);
@@ -919,11 +919,11 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                     const newCacheKey = isMRMS ? `mrms-${mrmsTimestamp}-${variable}` : `${model}-${date}-${run}-${forecastHour}-${variable}`;
                     preloadedDataCache.current.set(newCacheKey, { ...cachedData, scale: dataScale, offset: dataOffset });
                 }
-                
+
                 previousStateRef.current = newState;
                 return;
             }
-            
+
             const needsFullLoad =
                 !hasInitialLoad.current ||
                 newState.model !== previousStateRef.current.model ||
@@ -958,42 +958,72 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                     setRenderProps(prev => ({ ...prev, opacity: newState.opacity }));
                 }
             }
-            
+
             previousStateRef.current = newState;
         };
-        // --- END REPLACEMENT ---
 
         handleStateChangeRef.current = handleStateChange;
-        
+
         const stableHandler = (newState) => {
-            const isOpacityOnlyChange = 
+            // OPTIMIZATION: If playing (high speed), prioritize MAP update and skip debounce
+            if (newState.isPlaying) {
+                // 1. Update Map FIRST (Native Enqueue)
+                if (handleStateChangeRef.current) {
+                    handleStateChangeRef.current(newState);
+                }
+
+                // 2. Update UI Slider SECOND
+                // This ensures the heavy map frame is processing while React reconciles the slider
+                props.onStateChange?.(newState);
+
+                if (debounceTimeoutRef.current) {
+                    clearTimeout(debounceTimeoutRef.current);
+                    debounceTimeoutRef.current = null;
+                }
+                return;
+            }
+
+            // --- Existing Logic for scrubbing/paused ---
+
+            // 1. Immediate Slider Update for responsiveness
+            props.onStateChange?.(newState);
+
+            if (debounceTimeoutRef.current) {
+                clearTimeout(debounceTimeoutRef.current);
+            }
+
+            // Opacity and Play state changes should be immediate for the native layer too
+            const isOpacityOnlyChange =
                 previousStateRef.current &&
                 newState.opacity !== previousStateRef.current.opacity &&
                 newState.variable === previousStateRef.current.variable &&
                 newState.forecastHour === previousStateRef.current.forecastHour &&
                 newState.mrmsTimestamp === previousStateRef.current.mrmsTimestamp &&
                 newState.model === previousStateRef.current.model &&
-                newState.units === previousStateRef.current.units &&
-                newState.date === previousStateRef.current.date &&
-                newState.run === previousStateRef.current.run;
-            
-            if (isOpacityOnlyChange) {
+                newState.units === previousStateRef.current.units;
+
+            const isPlayStateOnlyChange =
+                previousStateRef.current &&
+                newState.isPlaying !== previousStateRef.current.isPlaying &&
+                newState.variable === previousStateRef.current.variable &&
+                newState.forecastHour === previousStateRef.current.forecastHour &&
+                newState.mrmsTimestamp === previousStateRef.current.mrmsTimestamp &&
+                newState.model === previousStateRef.current.model &&
+                newState.units === previousStateRef.current.units;
+
+            if (isOpacityOnlyChange || isPlayStateOnlyChange || !previousStateRef.current) {
                 if (handleStateChangeRef.current) {
                     handleStateChangeRef.current(newState);
                 }
                 return;
             }
-            
-            if (debounceTimeoutRef.current) {
-                clearTimeout(debounceTimeoutRef.current);
-            }
 
             debounceTimeoutRef.current = setTimeout(() => {
                 if (handleStateChangeRef.current) {
                     handleStateChangeRef.current(newState);
                 }
                 debounceTimeoutRef.current = null;
-            }, 50);
+            }, 16); // ~60fps map updates
         };
 
         core.on('state:change', stableHandler);
@@ -1005,7 +1035,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             }
         };
     }, [core]);
-    
+
     useEffect(() => {
         return () => {
             preloadedDataCache.current.clear();
@@ -1013,9 +1043,9 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             lastProcessedState.current = null;
         };
     }, []);
-    
+
     const lastInspectorUpdateRef = useRef(0);
-    const INSPECTOR_THROTTLE_MS = 50; 
+    const INSPECTOR_THROTTLE_MS = 50;
 
     useEffect(() => {
         if (!core || !inspectorEnabled) {
@@ -1026,16 +1056,16 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             if (!center || !Array.isArray(center) || center.length !== 2) {
                 return;
             }
-            
+
             // Throttle updates
             const now = Date.now();
             if (now - lastInspectorUpdateRef.current < INSPECTOR_THROTTLE_MS) {
                 return;
             }
             lastInspectorUpdateRef.current = now;
-            
+
             const [longitude, latitude] = center;
-            
+
             const payload = await getValueAtPoint(longitude, latitude);
             onInspect?.(payload);
         };
@@ -1062,10 +1092,10 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
         const triggerReinspection = () => {
             const mapRef = mapRegistry.getMap();
             const center = mapRef?._currentCenter;
-            
+
             if (center && Array.isArray(center) && center.length === 2) {
                 const [longitude, latitude] = center;
-                
+
                 getValueAtPoint(longitude, latitude).then(payload => {
                     onInspect?.(payload);
                 });
@@ -1078,7 +1108,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
         return () => clearTimeout(timer);
     }, [
         core?.state?.variable,
-        core?.state?.model, 
+        core?.state?.model,
         core?.state?.forecastHour,
         core?.state?.mrmsTimestamp,
         core?.state?.units,
@@ -1090,22 +1120,22 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
         if (!core) {
             return;
         }
-        
+
         const handleCameraChange = (center) => {
             if (core && center) {
                 core.setMapCenter(center);
             }
         };
-        
+
         // Register with the global registry
         mapRegistry.addCameraListener(handleCameraChange);
-        
+
         // Try to get initial center
         const mapRef = mapRegistry.getMap();
         if (mapRef?._currentCenter) {
             handleCameraChange(mapRef._currentCenter);
         }
-        
+
         return () => {
             mapRegistry.removeCameraListener(handleCameraChange);
         };