@aguacerowx/react-native 0.0.21 → 0.0.23

package/src/WeatherLayerManager.js

@@ -67,13 +67,19 @@ AguaceroCore.prototype.setMapCenter = function(center) {
 };
 
 export const WeatherLayerManager = forwardRef((props, ref) => {
-    const { inspectorEnabled, onInspect, apiKey, customColormaps, ...restProps } = props;
+    // EDIT: Destructure the new props
+    const { inspectorEnabled, onInspect, apiKey, customColormaps, initialMode, initialVariable, ...restProps } = props;
     const context = useContext(AguaceroContext);
     
     // Create the core here instead of getting it from context
     const core = useMemo(() => new AguaceroCore({ 
         apiKey: apiKey,
-        customColormaps: customColormaps 
+        customColormaps: customColormaps,
+        // ADD: Pass layerOptions to the core's constructor
+        layerOptions: {
+            mode: initialMode,
+            variable: initialVariable
+        }
     }), [apiKey]);
     
     const gridLayerRef = useRef(null);
@@ -134,183 +140,202 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
         };
     }, [core]);
 
-const preloadAllFramesToDisk = (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
-    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) {
-        const gridModel = isMRMS ? 'mrms' : model;
-        const { corners, gridDef } = core._getGridCornersAndDef(gridModel);
-        gridLayerRef.current.updateGeometry(corners, gridDef);
-        cachedGeometry.current = { model: gridModel, variable };
-
-        const { colormap, baseUnit } = core._getColormapForVariable(variable);
-        const toUnit = core._getTargetUnit(baseUnit, units);
-        const finalColormap = core._convertColormapUnits(colormap, baseUnit, toUnit);
-        const dataRange = [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;
+    const preloadAllFramesToDisk = (state) => {
         
-        setRenderProps({ opacity: state.opacity, dataRange: dataRange });
-        hasInitialLoad.current = true;
-    }
+        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...');
 
-    // Apply the same filtering logic as in AguaceroCore._emitStateChange
-    let filteredHours = availableHours;
-    if (!isMRMS && variable === 'ptypeRefl' && model === 'hrrr' && availableHours && availableHours.length > 0) {
-        filteredHours = availableHours.filter(hour => hour !== 0);
-    }
+        const { isMRMS, model, date, run, variable, units, availableHours, availableTimestamps, forecastHour, mrmsTimestamp } = state;
 
-    const allFrames = isMRMS ? availableTimestamps : filteredHours;
-    if (!allFrames || allFrames.length === 0) {
-        console.warn('🟡 [preloadAllFramesToDisk] No frames available to download.');
-        return;
-    }
+        // NEW: 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`);
+        }
 
-    const currentFrame = isMRMS ? mrmsTimestamp : effectiveForecastHour;
-    const prioritizedFrames = [
-        currentFrame,
-        ...allFrames.filter(frame => frame !== currentFrame)
-    ];
-    console.log(`[Preload] Prioritizing frame: ${currentFrame}. Total frames: ${prioritizedFrames.length}`);
+        if (!cachedGeometry.current || !cachedColormap.current) {
+            const gridModel = isMRMS ? 'mrms' : model;
+            const { corners, gridDef } = core._getGridCornersAndDef(gridModel);
+            gridLayerRef.current.updateGeometry(corners, gridDef);
+            cachedGeometry.current = { model: gridModel, variable };
 
-    const { corners, gridDef } = core._getGridCornersAndDef(isMRMS ? 'mrms' : model);
-    const { nx, ny } = gridDef.grid_params;
+            const { colormap, baseUnit } = core._getColormapForVariable(variable);
+            const toUnit = core._getTargetUnit(baseUnit, units);
+            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];
+                }
+            } else {
+                dataRange = [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({ opacity: state.opacity, dataRange: dataRange });
+            hasInitialLoad.current = true;
+        }
 
-    prioritizedFrames.forEach((frame, index) => {
-        const cacheKey = isMRMS ? `mrms-${frame}-${variable}` : `${model}-${date}-${run}-${frame}-${variable}`;
-        if (preloadedDataCache.current.has(cacheKey)) {
-            return;
+        // Apply the same filtering logic as in AguaceroCore._emitStateChange
+        let filteredHours = availableHours;
+        if (!isMRMS && variable === 'ptypeRefl' && model === 'hrrr' && availableHours && availableHours.length > 0) {
+            filteredHours = availableHours.filter(hour => hour !== 0);
         }
 
-        let resourcePath;
-        if (isMRMS) {
-            const frameDate = new Date(frame * 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}/${frame}/0/${variable}/0`;
-        } else {
-            resourcePath = `/grids/${model}/${date}/${run}/${frame}/${variable}/0`;
+        const allFrames = isMRMS ? availableTimestamps : filteredHours;
+        if (!allFrames || allFrames.length === 0) {
+            console.warn('🟡 [preloadAllFramesToDisk] No frames available to download.');
+            return;
         }
 
-        const url = `${core.baseGridUrl}${resourcePath}?apiKey=${core.apiKey}`;
-        const options = { url, apiKey: core.apiKey, bundleId: core.bundleId };
+        const currentFrame = isMRMS ? mrmsTimestamp : effectiveForecastHour;
 
-        WeatherFrameProcessorModule.processFrame(options)
-            .then(result => {
-                if (!result || !result.filePath) {
-                    console.warn(`⚠️ [preloadAllFramesToDisk] Failed frame ${frame}: No 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;
+        // --- EDIT: 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) => {
+            const cacheKey = isMRMS ? `mrms-${frame}-${variable}` : `${model}-${date}-${run}-${frame}-${variable}`;
+            if (preloadedDataCache.current.has(cacheKey)) {
+                return;
+            }
+
+            let resourcePath;
+            if (isMRMS) {
+                const frameDate = new Date(frame * 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}/${frame}/0/${variable}/0`;
+            } else {
+                resourcePath = `/grids/${model}/${date}/${run}/${frame}/${variable}/0`;
+            }
+
+            const url = `${core.baseGridUrl}${resourcePath}?apiKey=${core.apiKey}`;
+            const options = { url, apiKey: core.apiKey, bundleId: core.bundleId };
+
+            WeatherFrameProcessorModule.processFrame(options)
+                .then(result => {
+                    if (!result || !result.filePath) {
+                        console.warn(`⚠️ [preloadAllFramesToDisk] Failed frame ${frame}: No 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(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
+                    
+                    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
                     };
-                } 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
-                            }
+                    
+                    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
                         };
-                        gridLayerRef.current.primeGpuCache(frameInfoForGpu);
+                    } 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);
+                        }
                     }
-                }
-            })
-            .catch(error => {
-                console.warn(`⚠️ [preloadAllFramesToDisk] Failed frame ${frame}:`, error);
-            });
-    });
-};
+                })
+                .catch(error => {
+                    console.warn(`⚠️ [preloadAllFramesToDisk] Failed frame ${frame}:`, error);
+                });
+        });
+    };
 
     const updateGPUWithCachedData = (state) => {
         const { model, date, run, forecastHour, variable, units, isMRMS, mrmsTimestamp } = state;
@@ -371,7 +396,16 @@ const preloadAllFramesToDisk = (state) => {
             const { colormap, baseUnit } = core._getColormapForVariable(variable);
             const toUnit = core._getTargetUnit(baseUnit, units);
             const finalColormap = core._convertColormapUnits(colormap, baseUnit, toUnit);
-            const dataRange = [finalColormap[0], finalColormap[finalColormap.length - 2]];
+            let dataRange;
+            if (variable === 'ptypeRefl' || variable === 'ptypeRate') {
+                if (isMRMS) {
+                    dataRange = [5, 380];
+                } else {
+                    dataRange = [5, 380];
+                }
+            } else {
+                dataRange = [finalColormap[0], finalColormap[finalColormap.length - 2]];
+            }
             const colormapBytes = _generateColormapBytes(finalColormap);
             const colormapAsBase64 = fromByteArray(colormapBytes);
             
@@ -618,7 +652,16 @@ const preloadAllFramesToDisk = (state) => {
                     // Update the colormap AND data range
                     const { colormap } = core._getColormapForVariable(variable);
                     const finalColormap = core._convertColormapUnits(colormap, baseUnit, toUnit);
-                    const dataRange = [finalColormap[0], finalColormap[finalColormap.length - 2]];
+                    let dataRange;
+                    if (variable === 'ptypeRefl' || variable === 'ptypeRate') {
+                        if (isMRMS) {
+                            dataRange = [5, 380];
+                        } else {
+                            dataRange = [5, 380];
+                        }
+                    } else {
+                        dataRange = [finalColormap[0], finalColormap[finalColormap.length - 2]];
+                    }
                     
                     const colormapBytes = _generateColormapBytes(finalColormap);
                     const colormapAsBase64 = fromByteArray(colormapBytes);