@aguacerowx/react-native 0.0.9 → 0.0.12

package/ios/InspectorModule.swift

@@ -1,64 +1,64 @@
-import Foundation
-import React
-
-@objc(InspectorModule)
-class InspectorModule: NSObject {
-    
-@objc(getValueAtGridIndex:j:resolver:rejecter:)
-    func getValueAtGridIndex(
-        i: NSNumber,
-        j: NSNumber,
-        resolve: @escaping RCTPromiseResolveBlock,
-        reject: @escaping RCTPromiseRejectBlock
-    ) {
-        DispatchQueue.global(qos: .userInitiated).async {
-            let cache = InspectorDataCache.shared
-            
-            guard let data = cache.lastDecompressedData else {
-                print("🔍 [Inspector] ERROR: No data in cache")
-                resolve(nil)
-                return
-            }
-            
-            let nx = cache.nx
-            let scale = cache.scale
-            let offset = cache.offset
-            let missing = cache.missing
-            let scaleType = cache.scaleType
-            
-            let index = j.intValue * nx + i.intValue
-            
-            guard index >= 0 && index < data.count else {
-                print("🔍 [Inspector] ERROR: Index out of bounds")
-                resolve(nil)
-                return
-            }
-            
-            // Read as signed value
-            let signedQuantizedValue = Int(Int8(bitPattern: data[index]))
-            let missingQuantized = Int(round(missing))
-            
-            // Check for missing value with tolerance
-            if abs(signedQuantizedValue - missingQuantized) < 1 {
-                resolve(nil)
-                return
-            }
-            
-            // Step 1: Linear dequantization
-            let intermediateValue = Double(signedQuantizedValue) * Double(scale) + Double(offset)
-            var finalValue = intermediateValue
-            
-            // Step 2: Apply sqrt inverse transformation if needed
-            if scaleType == 1 {
-                finalValue = intermediateValue * abs(intermediateValue)
-            } 
-            
-            resolve(finalValue)
-        }
-    }
-    
-    @objc
-    static func requiresMainQueueSetup() -> Bool {
-        return false
-    }
+import Foundation
+import React
+
+@objc(InspectorModule)
+class InspectorModule: NSObject {
+    
+@objc(getValueAtGridIndex:j:resolver:rejecter:)
+    func getValueAtGridIndex(
+        i: NSNumber,
+        j: NSNumber,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            let cache = InspectorDataCache.shared
+            
+            guard let data = cache.lastDecompressedData else {
+                print("🔍 [Inspector] ERROR: No data in cache")
+                resolve(nil)
+                return
+            }
+            
+            let nx = cache.nx
+            let scale = cache.scale
+            let offset = cache.offset
+            let missing = cache.missing
+            let scaleType = cache.scaleType
+            
+            let index = j.intValue * nx + i.intValue
+            
+            guard index >= 0 && index < data.count else {
+                print("🔍 [Inspector] ERROR: Index out of bounds")
+                resolve(nil)
+                return
+            }
+            
+            // Read as signed value
+            let signedQuantizedValue = Int(Int8(bitPattern: data[index]))
+            let missingQuantized = Int(round(missing))
+            
+            // Check for missing value with tolerance
+            if abs(signedQuantizedValue - missingQuantized) < 1 {
+                resolve(nil)
+                return
+            }
+            
+            // Step 1: Linear dequantization
+            let intermediateValue = Double(signedQuantizedValue) * Double(scale) + Double(offset)
+            var finalValue = intermediateValue
+            
+            // Step 2: Apply sqrt inverse transformation if needed
+            if scaleType == 1 {
+                finalValue = intermediateValue * abs(intermediateValue)
+            } 
+            
+            resolve(finalValue)
+        }
+    }
+    
+    @objc
+    static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
 }

package/ios/Shaders.metal

@@ -1,131 +1,131 @@
-#include <metal_stdlib>
-using namespace metal;
-
-// Struct to match the vertex buffer layout in Swift
-struct Vertex {
-    float2 position [[attribute(0)]];
-    float2 texCoord [[attribute(1)]];
-};
-
-// Struct for passing data from vertex to fragment shader
-struct RasterizerData {
-    float4 position [[position]];
-    float2 texCoord;
-};
-
-// Uniforms passed from the CPU to the fragment shader
-struct FragmentUniforms {
-    float opacity;
-    float2 dataRange;
-    float scale;
-    float offset;
-    float missingQuantized;
-    float2 textureSize;
-    int smoothing;
-    int scaleType; // 0 for linear, 1 for sqrt
-};
-
-// --- Vertex Shader (Unchanged) ---
-vertex RasterizerData vertex_main(const Vertex in [[stage_in]],
-                                  constant float4x4 &mvp [[buffer(1)]]) {
-    RasterizerData out;
-    out.position = mvp * float4(in.position, 0.0, 1.0);
-    out.texCoord = in.texCoord;
-    return out;
-}
-
-float sampleDataTextureSmooth(
-    texture2d<float, access::sample> dataTexture,
-    sampler dataSampler,
-    float2 uv,
-    constant FragmentUniforms &uniforms)
-{
-    float missing_value = uniforms.missingQuantized + 128.0;
-
-    // Calculate the fractional part for interpolation and the size of one texel.
-    float2 texel_size = 1.0 / uniforms.textureSize;
-    float2 pixel_coord = uv * uniforms.textureSize;
-    float2 pixel_floor = floor(pixel_coord - 0.5);
-    float2 f = fract(pixel_coord - 0.5);
-
-    // Calculate the precise UV coordinates for the CENTER of the four surrounding texels.
-    float2 uv00 = (pixel_floor + float2(0.5, 0.5)) * texel_size;
-    float2 uv10 = (pixel_floor + float2(1.5, 0.5)) * texel_size;
-    float2 uv01 = (pixel_floor + float2(0.5, 1.5)) * texel_size;
-    float2 uv11 = (pixel_floor + float2(1.5, 1.5)) * texel_size;
-
-    // Sample the four corner texels.
-    float s00 = dataTexture.sample(dataSampler, uv00).r * 255.0;
-    float s10 = dataTexture.sample(dataSampler, uv10).r * 255.0;
-    float s01 = dataTexture.sample(dataSampler, uv01).r * 255.0;
-    float s11 = dataTexture.sample(dataSampler, uv11).r * 255.0;
-
-    // THE CRITICAL CHECK: If any surrounding pixel is a "missing" value,
-    // treat this entire fragment as missing to prevent interpolation.
-    if (abs(s00 - missing_value) < 0.5 ||
-        abs(s10 - missing_value) < 0.5 ||
-        abs(s01 - missing_value) < 0.5 ||
-        abs(s11 - missing_value) < 0.5)
-    {
-        return missing_value;
-    }
-
-    // All neighbors are valid data, so we can safely perform manual bilinear interpolation.
-    float s0 = mix(s00, s10, f.x); // Interpolate the top row
-    float s1 = mix(s01, s11, f.x); // Interpolate the bottom row
-    
-    // --- THE FIX IS HERE ---
-    // Remove the incorrect "1.0 - f.y" inversion. The vertical mix should use f.y directly.
-    return mix(s0, s1, f.y);
-}
-
-// --- Fragment Shader (NEW & IMPROVED) ---
-fragment float4 fragment_main(RasterizerData in [[stage_in]],
-                                constant FragmentUniforms &uniforms [[buffer(0)]],
-                                texture2d<float, access::sample> dataTexture [[texture(0)]],
-                                texture2d<float, access::sample> colormapTexture [[texture(1)]],
-                                sampler dataSampler [[sampler(0)]],
-                                sampler colormapSampler [[sampler(1)]])
-{
-    // Choose the sampling method based on the smoothing uniform.
-    float value_in_texture;
-    if (uniforms.smoothing == 1) {
-        // Use our custom function that prevents edge artifacts.
-        value_in_texture = sampleDataTextureSmooth(dataTexture, dataSampler, in.texCoord, uniforms);
-    } else {
-        // Smoothing is off. The sampler is already set to 'nearest' by the Swift code,
-        // so a standard sample call produces the correct pixelated result.
-        value_in_texture = dataTexture.sample(dataSampler, in.texCoord).r * 255.0;
-    }
-
-    float missing_value = uniforms.missingQuantized + 128.0;
-
-    // Discard if the pixel is a predefined missing value (either originally or from our function).
-    if (abs(value_in_texture - missing_value) < 0.5) {
-        discard_fragment();
-    }
-
-    // Dequantize the value to its real-world representation.
-    float quantized_value = value_in_texture - 128.0;
-    float intermediate_value = quantized_value * uniforms.scale + uniforms.offset;
-    float raw_value = intermediate_value;
-    
-    // Apply non-linear inverse scaling if specified.
-    if (uniforms.scaleType == 1) { // 'sqrt'
-        raw_value = intermediate_value * abs(intermediate_value);
-    }
-    
-    // Discard if the data is below the specified visible range.
-    if (raw_value < uniforms.dataRange.x) {
-        discard_fragment();
-    }
-    
-    // Normalize the value to a 0-1 coordinate for colormap lookup.
-    float colormap_coord = (raw_value - uniforms.dataRange.x) / (uniforms.dataRange.y - uniforms.dataRange.x);
-    colormap_coord = clamp(colormap_coord, 0.0, 1.0);
-    
-    // Sample the colormap and apply final opacity.
-    float4 color = colormapTexture.sample(colormapSampler, float2(colormap_coord, 0.5));
-    
-    return float4(color.rgb, color.a * uniforms.opacity);
+#include <metal_stdlib>
+using namespace metal;
+
+// Struct to match the vertex buffer layout in Swift
+struct Vertex {
+    float2 position [[attribute(0)]];
+    float2 texCoord [[attribute(1)]];
+};
+
+// Struct for passing data from vertex to fragment shader
+struct RasterizerData {
+    float4 position [[position]];
+    float2 texCoord;
+};
+
+// Uniforms passed from the CPU to the fragment shader
+struct FragmentUniforms {
+    float opacity;
+    float2 dataRange;
+    float scale;
+    float offset;
+    float missingQuantized;
+    float2 textureSize;
+    int smoothing;
+    int scaleType; // 0 for linear, 1 for sqrt
+};
+
+// --- Vertex Shader (Unchanged) ---
+vertex RasterizerData vertex_main(const Vertex in [[stage_in]],
+                                  constant float4x4 &mvp [[buffer(1)]]) {
+    RasterizerData out;
+    out.position = mvp * float4(in.position, 0.0, 1.0);
+    out.texCoord = in.texCoord;
+    return out;
+}
+
+float sampleDataTextureSmooth(
+    texture2d<float, access::sample> dataTexture,
+    sampler dataSampler,
+    float2 uv,
+    constant FragmentUniforms &uniforms)
+{
+    float missing_value = uniforms.missingQuantized + 128.0;
+
+    // Calculate the fractional part for interpolation and the size of one texel.
+    float2 texel_size = 1.0 / uniforms.textureSize;
+    float2 pixel_coord = uv * uniforms.textureSize;
+    float2 pixel_floor = floor(pixel_coord - 0.5);
+    float2 f = fract(pixel_coord - 0.5);
+
+    // Calculate the precise UV coordinates for the CENTER of the four surrounding texels.
+    float2 uv00 = (pixel_floor + float2(0.5, 0.5)) * texel_size;
+    float2 uv10 = (pixel_floor + float2(1.5, 0.5)) * texel_size;
+    float2 uv01 = (pixel_floor + float2(0.5, 1.5)) * texel_size;
+    float2 uv11 = (pixel_floor + float2(1.5, 1.5)) * texel_size;
+
+    // Sample the four corner texels.
+    float s00 = dataTexture.sample(dataSampler, uv00).r * 255.0;
+    float s10 = dataTexture.sample(dataSampler, uv10).r * 255.0;
+    float s01 = dataTexture.sample(dataSampler, uv01).r * 255.0;
+    float s11 = dataTexture.sample(dataSampler, uv11).r * 255.0;
+
+    // THE CRITICAL CHECK: If any surrounding pixel is a "missing" value,
+    // treat this entire fragment as missing to prevent interpolation.
+    if (abs(s00 - missing_value) < 0.5 ||
+        abs(s10 - missing_value) < 0.5 ||
+        abs(s01 - missing_value) < 0.5 ||
+        abs(s11 - missing_value) < 0.5)
+    {
+        return missing_value;
+    }
+
+    // All neighbors are valid data, so we can safely perform manual bilinear interpolation.
+    float s0 = mix(s00, s10, f.x); // Interpolate the top row
+    float s1 = mix(s01, s11, f.x); // Interpolate the bottom row
+    
+    // --- THE FIX IS HERE ---
+    // Remove the incorrect "1.0 - f.y" inversion. The vertical mix should use f.y directly.
+    return mix(s0, s1, f.y);
+}
+
+// --- Fragment Shader (NEW & IMPROVED) ---
+fragment float4 fragment_main(RasterizerData in [[stage_in]],
+                                constant FragmentUniforms &uniforms [[buffer(0)]],
+                                texture2d<float, access::sample> dataTexture [[texture(0)]],
+                                texture2d<float, access::sample> colormapTexture [[texture(1)]],
+                                sampler dataSampler [[sampler(0)]],
+                                sampler colormapSampler [[sampler(1)]])
+{
+    // Choose the sampling method based on the smoothing uniform.
+    float value_in_texture;
+    if (uniforms.smoothing == 1) {
+        // Use our custom function that prevents edge artifacts.
+        value_in_texture = sampleDataTextureSmooth(dataTexture, dataSampler, in.texCoord, uniforms);
+    } else {
+        // Smoothing is off. The sampler is already set to 'nearest' by the Swift code,
+        // so a standard sample call produces the correct pixelated result.
+        value_in_texture = dataTexture.sample(dataSampler, in.texCoord).r * 255.0;
+    }
+
+    float missing_value = uniforms.missingQuantized + 128.0;
+
+    // Discard if the pixel is a predefined missing value (either originally or from our function).
+    if (abs(value_in_texture - missing_value) < 0.5) {
+        discard_fragment();
+    }
+
+    // Dequantize the value to its real-world representation.
+    float quantized_value = value_in_texture - 128.0;
+    float intermediate_value = quantized_value * uniforms.scale + uniforms.offset;
+    float raw_value = intermediate_value;
+    
+    // Apply non-linear inverse scaling if specified.
+    if (uniforms.scaleType == 1) { // 'sqrt'
+        raw_value = intermediate_value * abs(intermediate_value);
+    }
+    
+    // Discard if the data is below the specified visible range.
+    if (raw_value < uniforms.dataRange.x) {
+        discard_fragment();
+    }
+    
+    // Normalize the value to a 0-1 coordinate for colormap lookup.
+    float colormap_coord = (raw_value - uniforms.dataRange.x) / (uniforms.dataRange.y - uniforms.dataRange.x);
+    colormap_coord = clamp(colormap_coord, 0.0, 1.0);
+    
+    // Sample the colormap and apply final opacity.
+    float4 color = colormapTexture.sample(colormapSampler, float2(colormap_coord, 0.5));
+    
+    return float4(color.rgb, color.a * uniforms.opacity);
 }

package/ios/WeatherFrameProcessorModule.m

@@ -1,16 +1,16 @@
-#import <React/RCTBridgeModule.h>
-
-@interface RCT_EXTERN_MODULE(WeatherFrameProcessorModule, NSObject)
-
-RCT_EXTERN_METHOD(processFrame:(NSDictionary *)options
-                  resolver:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(cancelAllFrames)
-
-+ (BOOL)requiresMainQueueSetup
-{
-    return NO;
-}
-
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(WeatherFrameProcessorModule, NSObject)
+
+RCT_EXTERN_METHOD(processFrame:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(cancelAllFrames)
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
 @end

package/ios/WeatherFrameProcessorModule.swift

@@ -1,104 +1,104 @@
-import Foundation
-import React
-
-@objc(WeatherFrameProcessorModule)
-class WeatherFrameProcessorModule: NSObject {
-
-    private var currentRunToken = 0
-    private let session = URLSession(configuration: .default)
-
-    @objc(cancelAllFrames)
-    func cancelAllFrames() {
-        // Incrementing the token effectively cancels any in-flight tasks
-        // as they will check their token against the new value upon completion.
-        currentRunToken += 1
-    }
-
-    @objc(processFrame:resolver:rejecter:)
-    func processFrame(options: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
-        let taskToken = self.currentRunToken
-
-        guard let urlString = options["url"] as? String, let url = URL(string: urlString) else {
-            reject("INVALID_URL", "The provided URL is not valid.", nil)
-            return
-        }
-
-        let apiKey = options["apiKey"] as? String ?? ""
-        let bundleId = options["bundleId"] as? String
-
-        var request = URLRequest(url: url)
-        request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
-        if let bundleId = bundleId {
-            request.setValue(bundleId, forHTTPHeaderField: "x-app-identifier")
-        }
-
-        let task = session.dataTask(with: request) { data, response, error in
-            if self.currentRunToken != taskToken {
-                // Task was cancelled
-                return
-            }
-
-            if let error = error {
-                reject("NETWORK_ERROR", "Failed to fetch frame data: \(error.localizedDescription)", error)
-                return
-            }
-
-            guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
-                let statusCode = (response as? HTTPURLResponse)?.statusCode ?? -1
-                reject("HTTP_ERROR", "HTTP request failed with status code: \(statusCode)", nil)
-                return
-            }
-
-            guard let data = data else {
-                reject("NO_DATA", "The server returned no data.", nil)
-                return
-            }
-
-            do {
-                guard let jsonResponse = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any],
-                      let b64CompressedData = jsonResponse["data"] as? String,
-                      let encoding = jsonResponse["encoding"] as? [String: Any],
-                      let scale = encoding["scale"] as? NSNumber,
-                      let offset = encoding["offset"] as? NSNumber,
-                      let missing = encoding["missing_quantized"] as? NSNumber else {
-                    reject("INVALID_RESPONSE", "The API response format was invalid.", nil)
-                    return
-                }
-                
-                guard let compressedData = Data(base64Encoded: b64CompressedData) else {
-                    reject("DECODING_ERROR", "Failed to decode base64 data string.", nil)
-                    return
-                }
-
-                let cacheDir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
-                let fileName = "frame_\(urlString.hashValue).zst"
-                let dataFile = cacheDir.appendingPathComponent(fileName)
-                
-                try compressedData.write(to: dataFile)
-
-                var responseMap: [String: Any] = [
-                    "filePath": dataFile.path,
-                    "scale": scale,
-                    "offset": offset,
-                    "missing": missing,
-                    "dataAsBase64": b64CompressedData // Pass this through for the initial load case
-                ]
-                
-                if let scaleType = encoding["scale_type"] as? String {
-                    responseMap["scaleType"] = scaleType
-                }
-
-                resolve(responseMap)
-
-            } catch {
-                reject("PROCESSING_ERROR", "Failed to process the frame data: \(error.localizedDescription)", error)
-            }
-        }
-        task.resume()
-    }
-    
-    @objc
-    static func requiresMainQueueSetup() -> Bool {
-        return false
-    }
+import Foundation
+import React
+
+@objc(WeatherFrameProcessorModule)
+class WeatherFrameProcessorModule: NSObject {
+
+    private var currentRunToken = 0
+    private let session = URLSession(configuration: .default)
+
+    @objc(cancelAllFrames)
+    func cancelAllFrames() {
+        // Incrementing the token effectively cancels any in-flight tasks
+        // as they will check their token against the new value upon completion.
+        currentRunToken += 1
+    }
+
+    @objc(processFrame:resolver:rejecter:)
+    func processFrame(options: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        let taskToken = self.currentRunToken
+
+        guard let urlString = options["url"] as? String, let url = URL(string: urlString) else {
+            reject("INVALID_URL", "The provided URL is not valid.", nil)
+            return
+        }
+
+        let apiKey = options["apiKey"] as? String ?? ""
+        let bundleId = options["bundleId"] as? String
+
+        var request = URLRequest(url: url)
+        request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
+        if let bundleId = bundleId {
+            request.setValue(bundleId, forHTTPHeaderField: "x-app-identifier")
+        }
+
+        let task = session.dataTask(with: request) { data, response, error in
+            if self.currentRunToken != taskToken {
+                // Task was cancelled
+                return
+            }
+
+            if let error = error {
+                reject("NETWORK_ERROR", "Failed to fetch frame data: \(error.localizedDescription)", error)
+                return
+            }
+
+            guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
+                let statusCode = (response as? HTTPURLResponse)?.statusCode ?? -1
+                reject("HTTP_ERROR", "HTTP request failed with status code: \(statusCode)", nil)
+                return
+            }
+
+            guard let data = data else {
+                reject("NO_DATA", "The server returned no data.", nil)
+                return
+            }
+
+            do {
+                guard let jsonResponse = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any],
+                      let b64CompressedData = jsonResponse["data"] as? String,
+                      let encoding = jsonResponse["encoding"] as? [String: Any],
+                      let scale = encoding["scale"] as? NSNumber,
+                      let offset = encoding["offset"] as? NSNumber,
+                      let missing = encoding["missing_quantized"] as? NSNumber else {
+                    reject("INVALID_RESPONSE", "The API response format was invalid.", nil)
+                    return
+                }
+                
+                guard let compressedData = Data(base64Encoded: b64CompressedData) else {
+                    reject("DECODING_ERROR", "Failed to decode base64 data string.", nil)
+                    return
+                }
+
+                let cacheDir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
+                let fileName = "frame_\(urlString.hashValue).zst"
+                let dataFile = cacheDir.appendingPathComponent(fileName)
+                
+                try compressedData.write(to: dataFile)
+
+                var responseMap: [String: Any] = [
+                    "filePath": dataFile.path,
+                    "scale": scale,
+                    "offset": offset,
+                    "missing": missing,
+                    "dataAsBase64": b64CompressedData // Pass this through for the initial load case
+                ]
+                
+                if let scaleType = encoding["scale_type"] as? String {
+                    responseMap["scaleType"] = scaleType
+                }
+
+                resolve(responseMap)
+
+            } catch {
+                reject("PROCESSING_ERROR", "Failed to process the frame data: \(error.localizedDescription)", error)
+            }
+        }
+        task.resume()
+    }
+    
+    @objc
+    static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
 }