@aguacerowx/react-native 0.0.29 → 0.0.30

package/src/WeatherLayerManager.js

@@ -171,30 +171,37 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             },
             setAutoRefresh,
             refreshData: () => {
-                console.log('[WeatherLayerManager RN] Manual data refresh triggered.');
-                // Call the internal update function, which is already in scope
                 _checkForUpdates();
             },
         };
     }, [core, autoRefreshInterval, _checkForUpdates]);
 
-    const preloadAllFramesToDisk = (state) => {
-        
+    const preloadAllFramesToDisk = async (state) => {
         if (hasPreloadedRef.current) {
-            console.log('✅ [Preload] Gating preload; already initiated for this dataset.');
             return;
         }
-        hasPreloadedRef.current = true;
-        console.log('🚀 [Preload] Initiating parallel preload for new dataset...');
 
         const { isMRMS, model, date, run, variable, units, availableHours, availableTimestamps, forecastHour, mrmsTimestamp } = state;
 
-        // NEW: Fix the current forecast hour if it's invalid for this variable/model combo
+        // CRITICAL: Don't start preloading if we don't have a valid current frame
+        if (isMRMS && (mrmsTimestamp == null || !availableTimestamps || availableTimestamps.length === 0)) {
+            hasPreloadedRef.current = false;
+            return;
+        }
+
+        if (!isMRMS && (forecastHour == null || !availableHours || availableHours.length === 0)) {
+            hasPreloadedRef.current = false;
+            return;
+        }
+
+        // Only mark as "has preloaded" after validation passes
+        hasPreloadedRef.current = true;
+
+        // Fix the current forecast hour if it's invalid for this variable/model combo
         let effectiveForecastHour = forecastHour;
         if (!isMRMS && variable === 'ptypeRefl' && model === 'hrrr' && forecastHour === 0) {
             const validHours = availableHours.filter(hour => hour !== 0);
             effectiveForecastHour = validHours.length > 0 ? validHours[0] : 0;
-            console.log(`⚠️ [Preload] Correcting invalid hour 0 to ${effectiveForecastHour} for HRRR ptypeRefl`);
         }
 
         if (!cachedGeometry.current || !cachedColormap.current) {
@@ -208,13 +215,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             const finalColormap = core._convertColormapUnits(colormap, baseUnit, toUnit);
             let dataRange;
             if (variable === 'ptypeRefl' || variable === 'ptypeRate') {
-                if (isMRMS) {
-                    console.log('🔧 Using MRMS ptype data range: 5-380');
-                    dataRange = [5, 380];
-                } else {
-                    console.log('🔧 Using Model ptype data range: 5-380');
-                    dataRange = [5, 380];
-                }
+                dataRange = isMRMS ? [5, 380] : [5, 380];
             } else {
                 dataRange = [finalColormap[0], finalColormap[finalColormap.length - 2]];
             }
@@ -237,29 +238,120 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
 
         const allFrames = isMRMS ? availableTimestamps : filteredHours;
         if (!allFrames || allFrames.length === 0) {
-            console.warn('🟡 [preloadAllFramesToDisk] No frames available to download.');
             return;
         }
 
         const currentFrame = isMRMS ? mrmsTimestamp : effectiveForecastHour;
 
-        // --- EDIT: Reverse the frame order to load from last to first ---
+        // Double-check currentFrame is valid
+        if (currentFrame == null) {
+            hasPreloadedRef.current = false;
+            return;
+        }
+
+        // Reverse the frame order to load from last to first
         const reversedFrames = [...allFrames].reverse();
         const framesToPreload = reversedFrames.filter(frame => frame !== currentFrame);
-        
-        // The final array will process the current frame first, then the rest in reverse chronological order.
-        const prioritizedFrames = [
-            currentFrame,
-            ...framesToPreload
-        ];
-        // --- END EDIT ---
-        
-        console.log(`[Preload] Prioritizing frame: ${currentFrame}. Total frames: ${prioritizedFrames.length}`);
 
         const { corners, gridDef } = core._getGridCornersAndDef(isMRMS ? 'mrms' : model);
         const { nx, ny } = gridDef.grid_params;
 
-        prioritizedFrames.forEach((frame, index) => {
+        // 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) {
+                const frameDate = new Date(currentFrame * 1000);
+                const y = frameDate.getUTCFullYear();
+                const m = (frameDate.getUTCMonth() + 1).toString().padStart(2, '0');
+                const d = frameDate.getUTCDate().toString().padStart(2, '0');
+                resourcePath = `/grids/mrms/${y}${m}${d}/${currentFrame}/0/${variable}/0`;
+            } else {
+                resourcePath = `/grids/${model}/${date}/${run}/${currentFrame}/${variable}/0`;
+            }
+
+            const url = `${core.baseGridUrl}${resourcePath}?apiKey=${core.apiKey}`;
+            const options = { url, apiKey: core.apiKey, bundleId: core.bundleId };
+
+            try {
+                const result = await WeatherFrameProcessorModule.processFrame(options);
+                
+                if (!result || !result.filePath) {
+                    return;
+                }
+                
+                const { baseUnit } = core._getColormapForVariable(variable);
+                const toUnit = core._getTargetUnit(baseUnit, units);
+                
+                let dataScale = result.scale;
+                let dataOffset = result.offset;
+                
+                let convertedScale = dataScale;
+                let convertedOffset = dataOffset;
+                
+                if (baseUnit !== toUnit) {
+                    const conversionFunc = getUnitConversionFunction(baseUnit, toUnit);
+                    if (conversionFunc) {
+                        if (result.scaleType === 'sqrt') {
+                            const physicalAtOffset = dataOffset * dataOffset;
+                            const physicalAtOffsetPlusScale = (dataOffset + dataScale) * (dataOffset + dataScale);
+                            const convertedPhysicalAtOffset = conversionFunc(physicalAtOffset);
+                            const convertedPhysicalAtOffsetPlusScale = conversionFunc(physicalAtOffsetPlusScale);
+                            convertedOffset = Math.sqrt(Math.abs(convertedPhysicalAtOffset)) * Math.sign(convertedPhysicalAtOffset);
+                            const newOffsetPlusScale = Math.sqrt(Math.abs(convertedPhysicalAtOffsetPlusScale)) * Math.sign(convertedPhysicalAtOffsetPlusScale);
+                            convertedScale = newOffsetPlusScale - convertedOffset;
+                        } else {
+                            convertedOffset = conversionFunc(dataOffset);
+                            const convertedOffsetPlusScale = conversionFunc(dataOffset + dataScale);
+                            convertedScale = convertedOffsetPlusScale - convertedOffset;
+                        }
+                    }
+                }
+                
+                const frameData = {
+                    filePath: result.filePath,
+                    nx, ny,
+                    scale: convertedScale,
+                    offset: convertedOffset,
+                    missing: result.missing,
+                    corners, 
+                    gridDef,
+                    scaleType: result.scaleType,
+                    originalScale: result.scale,
+                    originalOffset: result.offset
+                };
+                
+                preloadedDataCache.current.set(currentCacheKey, frameData);
+
+                // Update the GPU with the current frame
+                gridLayerRef.current.updateDataTextureFromFile(
+                    frameData.filePath,
+                    frameData.nx, frameData.ny,
+                    frameData.scale, frameData.offset, frameData.missing,
+                    frameData.scaleType
+                );
+
+                currentGridDataRef.current = {
+                    nx: frameData.nx,
+                    ny: frameData.ny,
+                    scale: frameData.scale,
+                    offset: frameData.offset,
+                    missing: frameData.missing,
+                    gridDef: frameData.gridDef,
+                    variable: variable,
+                    units: units,
+                    scaleType: frameData.scaleType
+                };
+            } catch (error) {
+                console.warn(`⚠️ [preloadAllFramesToDisk] Failed frame ${currentFrame}:`, error);
+                hasPreloadedRef.current = false;
+                return;
+            }
+        }
+
+        // NOW preload the rest of the frames asynchronously
+        framesToPreload.forEach((frame) => {
             const cacheKey = isMRMS ? `mrms-${frame}-${variable}` : `${model}-${date}-${run}-${frame}-${variable}`;
             if (preloadedDataCache.current.has(cacheKey)) {
                 return;
@@ -329,44 +421,21 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                     
                     preloadedDataCache.current.set(cacheKey, frameData);
 
-                    const isCurrentFrame = index === 0;
-
-                    if (isCurrentFrame) {
-                        console.log(`🎯 [Preload] Using FAST LANE to process and draw current frame (${frame}) immediately.`);
-                        gridLayerRef.current.updateDataTextureFromFile(
-                            frameData.filePath,
-                            frameData.nx, frameData.ny,
-                            frameData.scale, frameData.offset, frameData.missing,
-                            frameData.scaleType
-                        );
-
-                        currentGridDataRef.current = {
-                            nx: frameData.nx,
-                            ny: frameData.ny,
-                            scale: frameData.scale,
-                            offset: frameData.offset,
-                            missing: frameData.missing,
-                            gridDef: frameData.gridDef,
-                            variable: variable,
-                            units: units
+                    if (Platform.OS === 'ios' && gridLayerRef.current.primeGpuCache) {
+                        const frameInfoForGpu = {
+                            [cacheKey]: {
+                                filePath: frameData.filePath, 
+                                nx: frameData.nx, 
+                                ny: frameData.ny,
+                                scale: frameData.scale,
+                                offset: frameData.offset,
+                                missing: frameData.missing,
+                                scaleType: frameData.scaleType || 'linear',
+                                originalScale: frameData.originalScale,
+                                originalOffset: frameData.originalOffset
+                            }
                         };
-                    } else {
-                        if (Platform.OS === 'ios' && gridLayerRef.current.primeGpuCache) {
-                            const frameInfoForGpu = {
-                                [cacheKey]: {
-                                    filePath: frameData.filePath, 
-                                    nx: frameData.nx, 
-                                    ny: frameData.ny,
-                                    scale: frameData.scale,
-                                    offset: frameData.offset,
-                                    missing: frameData.missing,
-                                    scaleType: frameData.scaleType || 'linear',
-                                    originalScale: frameData.originalScale,
-                                    originalOffset: frameData.originalOffset
-                                }
-                            };
-                            gridLayerRef.current.primeGpuCache(frameInfoForGpu);
-                        }
+                        gridLayerRef.current.primeGpuCache(frameInfoForGpu);
                     }
                 })
                 .catch(error => {
@@ -415,12 +484,6 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                     units: units,
                     scaleType: cachedData.scaleType
                 };
-                
-                console.log('📱 [iOS] Updated currentGridDataRef for inspector:', {
-                    scale: cachedData.scale,
-                    offset: cachedData.offset,
-                    scaleType: cachedData.scaleType  // ADD THIS
-                });
             }
             
             // Now call setActiveFrame (which will async update the native cache)
@@ -431,8 +494,6 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
         const cachedData = preloadedDataCache.current.get(cacheKey);
         
         if (!cachedData) {
-            const timeKey = isMRMS ? `timestamp ${mrmsTimestamp}` : `hour +${forecastHour}`;
-            console.log(`⏳ [updateGPUWithCachedData] Frame not ready yet for ${timeKey}. Still preloading...`); // CHANGED
             return false;
         }
         
@@ -551,7 +612,6 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
         
         // ADD THIS: Check if we have valid data before attempting inspection
         if (!currentGridDataRef.current) {
-            console.log('🔍 [Inspector] No grid data available');
             return null;
         }
         
@@ -573,7 +633,6 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             const minThreshold = finalColormap[0];
             
             if (value < minThreshold) {
-                console.log('🔍 [Inspector] Rejected: below threshold');  // ADD THIS LOG
                 return null;
             }
 
@@ -619,7 +678,6 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 core.mrmsStatus = mrmsStatus;
                 core._emitStateChange(); // Update UI slider without changing selection
 
-                console.log(`[Auto-Refresh] Preloading ${newTimestampsToPreload.length} new MRMS frames.`);
                 const { corners, gridDef } = core._getGridCornersAndDef('mrms');
                 const { nx, ny } = gridDef.grid_params;
 
@@ -681,11 +739,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             return;
         }
 
-        // --- REPLACE THIS ENTIRE FUNCTION ---
         const handleStateChange = async (newState) => {
-            // --- FIX 1: Notify the parent component IMMEDIATELY ---
-            // This ensures the parent UI (like sliders) always gets the latest state,
-            // including updated lists of available hours or timestamps.
             props.onStateChange?.(newState);
 
             if (!previousStateRef.current) {
@@ -718,12 +772,8 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 newState.model === previousStateRef.current?.model &&
                 newState.units === previousStateRef.current?.units &&
                 newState.opacity === previousStateRef.current?.opacity;
-            
-            // This gate now correctly prevents only redundant *internal* processing.
-            // The parent has already been notified.
+
             if (!isOpacityOnlyChange && !isPlayStateOnlyChange && lastProcessedState.current === stateKey) {
-                // --- FIX 2: Update the previous state ref before returning ---
-                // This is critical to prevent stale comparisons on the next state change event.
                 previousStateRef.current = newState;
                 return;
             }
@@ -943,9 +993,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
         };
     }, [inspectorEnabled, onInspect, core, context]);
 
-    // Add this new useEffect after the existing inspector useEffect
     useEffect(() => {
-        // Trigger re-inspection when state changes (variable, model, forecast hour, etc.)
         if (!core || !inspectorEnabled) {
             return;
         }