@aguacerowx/react-native 0.0.20 → 0.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aguacerowx/react-native",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "Native weather rendering for React Native",
   "license": "ISC",
   "author": "Michael Barletta",
@@ -28,7 +28,7 @@
     "android/src/main/java/com/facebook/react/viewmanagers"
   ],
   "scripts": {
-    "compile-shaders": "./scripts/compile-shaders.sh",
+    "compile-shaders": "node scripts/compile-shaders.js",
     "clean": "node -e \"require('fs').rmSync('lib', {recursive: true, force: true})\"",
     "build": "npm run compile-shaders && npm run clean && bob build",
     "prepare": "npm run build"
@@ -44,7 +44,7 @@
     "react-native-device-info": ">=10.0.0"
   },
   "dependencies": {
-    "@aguacerowx/javascript-sdk": "^0.0.11",
+    "@aguacerowx/javascript-sdk": "^0.0.15",
     "base64-js": "^1.5.1"
   },
   "react-native-builder-bob": {

package/src/WeatherLayerManager.js

@@ -134,171 +134,194 @@ 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 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;
+    const { isMRMS, model, date, run, variable, units, availableHours, availableTimestamps, forecastHour, mrmsTimestamp } = state;
 
-        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 };
+    // 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 { 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;
-            
-            setRenderProps({ opacity: state.opacity, dataRange: dataRange });
-            hasInitialLoad.current = true;
+    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);
+        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;
+    }
 
-        const allFrames = isMRMS ? availableTimestamps : availableHours;
-        if (!allFrames || allFrames.length === 0) {
-            console.warn('🟡 [preloadAllFramesToDisk] No frames available to download.');
-            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);
+    }
 
-        const currentFrame = isMRMS ? mrmsTimestamp : forecastHour;
-        const prioritizedFrames = [
-            currentFrame,
-            ...allFrames.filter(frame => frame !== currentFrame)
-        ];
-        console.log(`[Preload] Prioritizing frame: ${currentFrame}. Total frames: ${prioritizedFrames.length}`);
+    const allFrames = isMRMS ? availableTimestamps : filteredHours;
+    if (!allFrames || allFrames.length === 0) {
+        console.warn('🟡 [preloadAllFramesToDisk] No frames available to download.');
+        return;
+    }
 
-        const { corners, gridDef } = core._getGridCornersAndDef(isMRMS ? 'mrms' : model);
-        const { nx, ny } = gridDef.grid_params;
+    const currentFrame = isMRMS ? mrmsTimestamp : effectiveForecastHour;
+    const prioritizedFrames = [
+        currentFrame,
+        ...allFrames.filter(frame => frame !== currentFrame)
+    ];
+    console.log(`[Preload] Prioritizing frame: ${currentFrame}. Total frames: ${prioritizedFrames.length}`);
 
-        prioritizedFrames.forEach((frame, index) => {
-            const cacheKey = isMRMS ? `mrms-${frame}-${variable}` : `${model}-${date}-${run}-${frame}-${variable}`;
-            if (preloadedDataCache.current.has(cacheKey)) {
-                return; // Use 'return' here as it's a forEach loop
-            }
+    const { corners, gridDef } = core._getGridCornersAndDef(isMRMS ? 'mrms' : model);
+    const { nx, ny } = gridDef.grid_params;
 
-            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`;
-            }
+    prioritizedFrames.forEach((frame, index) => {
+        const cacheKey = isMRMS ? `mrms-${frame}-${variable}` : `${model}-${date}-${run}-${frame}-${variable}`;
+        if (preloadedDataCache.current.has(cacheKey)) {
+            return;
+        }
 
-            const url = `${core.baseGridUrl}${resourcePath}?apiKey=${core.apiKey}`;
-            const options = { url, apiKey: core.apiKey, bundleId: core.bundleId };
+        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`;
+        }
 
-            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;
-                    
-                    // Calculate converted values for immediate use
-                    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 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;
                         }
                     }
-                    
-                    // Store with ORIGINAL values for unit conversion later
-                    const frameData = {
-                        filePath: result.filePath,
-                        nx, ny,
-                        scale: convertedScale,  // Current converted values
-                        offset: convertedOffset,
-                        missing: result.missing,
-                        corners, 
-                        gridDef,
-                        scaleType: result.scaleType,
-                        originalScale: result.scale,  // CRITICAL: Always original
-                        originalOffset: result.offset  // CRITICAL: Always original
+                }
+                
+                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
                     };
-                    
-                    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
+                } 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
+                            }
                         };
-                    } else {
-                        if (Platform.OS === 'ios' && gridLayerRef.current.primeGpuCache) {
-                            const frameInfoForGpu = {
-                                [cacheKey]: {
-                                    filePath: frameData.filePath, 
-                                    nx: frameData.nx, 
-                                    ny: frameData.ny,
-                                    scale: frameData.scale,  // Current converted scale
-                                    offset: frameData.offset,  // Current converted offset
-                                    missing: frameData.missing,
-                                    scaleType: frameData.scaleType || 'linear',
-                                    originalScale: frameData.originalScale,  // ADD THIS
-                                    originalOffset: frameData.originalOffset  // ADD THIS
-                                }
-                            };
-                            gridLayerRef.current.primeGpuCache(frameInfoForGpu);
-                        }
+                        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;
@@ -359,7 +382,16 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             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);
             
@@ -606,7 +638,16 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                     // 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);