@aguacerowx/react-native 0.0.34 → 0.0.36

package/lib/module/lib/commonjs/ios/GridRenderLayerBridge.swift

@@ -0,0 +1,37 @@
+import Foundation
+@_spi(Experimental) import MapboxMaps
+
+@objc public class GridRenderLayerBridge: NSObject {
+    
+    @objc public static func addCustomLayer(
+        to mapView: MapView,
+        layerHost: CustomLayerHost,
+        layerId: String,
+        belowLayerId: String?
+    ) -> Bool {
+        let position: LayerPosition? = belowLayerId.map { .below($0) }
+        var customLayer = CustomLayer(id: layerId, renderer: layerHost)
+        
+        do {
+            try mapView.mapboxMap.addLayer(customLayer, layerPosition: position)
+            return true
+        } catch {
+            print("❌ [GridRenderLayerBridge] Failed to add layer: \(error)")
+            return false
+        }
+    }
+    
+    @objc public static func triggerRepaint(on mapView: MapView) {
+        mapView.mapboxMap.triggerRepaint()
+    }
+    
+    // ADD THIS NEW METHOD
+    @objc public static func layerExists(in mapView: MapView, layerId: String) -> Bool {
+        do {
+            _ = try mapView.mapboxMap.layer(withId: layerId)
+            return true
+        } catch {
+            return false
+        }
+    }
+}

package/lib/module/lib/commonjs/ios/GridRenderLayerManager.mm

@@ -0,0 +1,158 @@
+#import <React/RCTViewManager.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTLog.h>
+#import "GridRenderLayerView.h"
+
+// Import Swift bridging header here
+#if __has_include("aguacerowx_react_native-Swift.h")
+    #import "aguacerowx_react_native-Swift.h"
+#else
+    #import <aguacerowx_react_native/aguacerowx_react_native-Swift.h>
+#endif
+
+@interface GridRenderLayerManager : RCTViewManager
+@end
+
+@implementation GridRenderLayerManager
+
+RCT_EXPORT_MODULE(GridRenderLayer)
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
+- (UIView *)view {
+    return [[GridRenderLayerView alloc] init];
+}
+
+// --- Props ---
+RCT_EXPORT_VIEW_PROPERTY(opacity, float)
+RCT_EXPORT_VIEW_PROPERTY(dataRange, NSArray)
+RCT_EXPORT_VIEW_PROPERTY(smoothing, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(belowID, NSString)
+
+// --- Commands ---
+RCT_EXPORT_METHOD(updateGeometry:(nonnull NSNumber *)reactTag
+                  corners:(NSDictionary *)corners
+                  gridDef:(NSDictionary *)gridDef)
+{
+    // OPTIMIZATION: Dispatch heavy geometry calculations to a high-priority background queue.
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
+        [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+            GridRenderLayerView *view = (GridRenderLayerView *)viewRegistry[reactTag];
+            if ([view isKindOfClass:[GridRenderLayerView class]]) {
+                [view.layerInstance updateGeometryWithCorners:corners gridDef:gridDef];
+            }
+        }];
+    });
+}
+
+
+RCT_EXPORT_METHOD(updateDataTexture:(nonnull NSNumber *)reactTag
+                  data:(NSString *)data
+                  nx:(nonnull NSNumber *)nx
+                  ny:(nonnull NSNumber *)ny
+                  scale:(nonnull NSNumber *)scale
+                  offset:(nonnull NSNumber *)offset
+                  missing:(nonnull NSNumber *)missing
+                  scaleType:(NSString *)scaleType)
+{
+    // OPTIMIZATION: Dispatch to a high-priority background queue immediately.
+    // This unblocks the main thread and starts the heaviest work (data processing) sooner.
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
+        [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+            GridRenderLayerView *view = (GridRenderLayerView *)viewRegistry[reactTag];
+            if ([view isKindOfClass:[GridRenderLayerView class]]) {
+                [view.layerInstance updateDataTextureWithData:data nx:nx ny:ny scale:scale offset:offset missing:missing scaleType:scaleType];
+            }
+        }];
+    });
+}
+
+RCT_EXPORT_METHOD(updateColormapTexture:(nonnull NSNumber *)reactTag
+                  colormapAsBase64:(NSString *)colormapAsBase64)
+{
+    // Don't block the main thread - dispatch to background first
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
+        [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+            GridRenderLayerView *view = (GridRenderLayerView *)viewRegistry[reactTag];
+            if ([view isKindOfClass:[GridRenderLayerView class]]) {
+                [view.layerInstance updateColormapTextureWithColormapAsBase64:colormapAsBase64];
+            }
+        }];
+    });
+}
+
+RCT_EXPORT_METHOD(updateDataParameters:(nonnull NSNumber *)reactTag
+                  scale:(nonnull NSNumber *)scale
+                  offset:(nonnull NSNumber *)offset
+                  missing:(nonnull NSNumber *)missing
+                  scaleType:(nonnull NSNumber *)scaleType)  // ADD THIS
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        GridRenderLayerView *view = (GridRenderLayerView *)viewRegistry[reactTag];
+        if ([view isKindOfClass:[GridRenderLayerView class]]) {
+            [view.layerInstance updateDataParametersWithScale:scale offset:offset missing:missing scaleType:scaleType];  // ADD scaleType here
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(clear:(nonnull NSNumber *)reactTag)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        GridRenderLayerView *view = (GridRenderLayerView *)viewRegistry[reactTag];
+        if ([view isKindOfClass:[GridRenderLayerView class]]) {
+            [view.layerInstance clear];
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(primeGpuCache:(nonnull NSNumber *)reactTag
+                  frameInfo:(NSDictionary *)frameInfo)
+{
+    // OPTIMIZATION: Dispatch this immediately to a background thread to unblock JS.
+    // The Swift implementation will then handle its own concurrency.
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+            GridRenderLayerView *view = (GridRenderLayerView *)viewRegistry[reactTag];
+            if ([view isKindOfClass:[GridRenderLayerView class]]) {
+                [view.layerInstance primeGpuCacheWithFrameInfo:frameInfo];
+            }
+        }];
+    });
+}
+
+RCT_EXPORT_METHOD(setActiveFrame:(nonnull NSNumber *)reactTag
+                  cacheKey:(NSString *)cacheKey)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        GridRenderLayerView *view = (GridRenderLayerView *)viewRegistry[reactTag];
+        if ([view isKindOfClass:[GridRenderLayerView class]]) {
+            [view.layerInstance setActiveFrameWithCacheKey:cacheKey];
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(clearGpuCache:(nonnull NSNumber *)reactTag)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        GridRenderLayerView *view = (GridRenderLayerView *)viewRegistry[reactTag];
+        if ([view isKindOfClass:[GridRenderLayerView class]]) {
+            [view.layerInstance clearGpuCache];
+        }
+    }];
+}
+
+// ADD THIS METHOD
+RCT_EXPORT_METHOD(setVariable:(nonnull NSNumber *)reactTag
+                  variable:(NSString *)variable)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        GridRenderLayerView *view = (GridRenderLayerView *)viewRegistry[reactTag];
+        if ([view isKindOfClass:[GridRenderLayerView class]]) {
+            [view setVariable:variable];
+        }
+    }];
+}
+
+@end

package/lib/module/lib/commonjs/ios/GridRenderLayerView.h

@@ -0,0 +1,31 @@
+#import <UIKit/UIKit.h>
+#import <React/RCTComponent.h>
+
+@class GridRenderLayer;
+@class MapView;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface GridRenderLayerView : UIView
+
+@property (nonatomic, strong) GridRenderLayer *layerInstance;
+@property (nonatomic, weak) MapView *mapView;
+@property (nonatomic, strong) NSString *layerId;
+@property (nonatomic, strong, nullable) NSString *belowID;
+
+// Property setters for React Native
+- (void)setOpacity:(float)opacity;
+- (void)setDataRange:(NSArray *)dataRange;
+- (void)setSmoothing:(BOOL)smoothing;
+- (void)setBelowID:(NSString *)belowID;
+- (void)setVariable:(NSString *)variable;
+
+// ADD THESE METHOD DECLARATIONS
+- (void)waitForStyleLoadAndAddLayer;
+- (void)pollForLayerExistence;
+- (void)findMapViewAndAddLayerInView:(UIView *)view;
+- (void)addLayerToMap;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/lib/module/lib/commonjs/ios/GridRenderLayerView.m

@@ -0,0 +1,217 @@
+#import "GridRenderLayerView.h"
+#import <React/RCTLog.h>
+#import <objc/runtime.h> 
+
+// Import Swift bridging header
+#if __has_include("aguacerowx_react_native-Swift.h")
+    #import "aguacerowx_react_native-Swift.h"
+#else
+    #import <aguacerowx_react_native/aguacerowx_react_native-Swift.h>
+#endif
+
+// Import MapboxMaps to get MapView definition
+@import MapboxMaps;
+
+@interface GridRenderLayerView ()
+@property (nonatomic, assign) BOOL isLayerAdded;
+@end
+
+@implementation GridRenderLayerView
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _layerId = [NSString stringWithFormat:@"weather-layer-%@", [[NSUUID UUID] UUIDString]];
+        _layerInstance = [[GridRenderLayer alloc] initWithId:_layerId];
+        _isLayerAdded = NO;
+    }
+    return self;
+}
+
+#pragma mark - Property Setters
+
+- (void)setOpacity:(float)opacity {
+    [self.layerInstance setOpacityWithValue:opacity];
+}
+
+- (void)setDataRange:(NSArray *)dataRange {
+    if (dataRange && dataRange.count == 2) {
+        [self.layerInstance setDataRangeWithValue:dataRange];
+    } else {
+        RCTLogError(@"❌ [GridRenderLayerView] Invalid dataRange: %@", dataRange);
+    }
+}
+
+- (void)setSmoothing:(BOOL)smoothing {
+    [self.layerInstance setSmoothingWithValue:smoothing];
+}
+
+- (void)setBelowID:(NSString *)belowID {
+    _belowID = belowID;
+}
+
+// ADD THIS METHOD
+- (void)setVariable:(NSString *)variable {
+    [self.layerInstance setVariableWithVariable:variable];
+}
+
+#pragma mark - View Lifecycle
+
+- (void)didMoveToWindow {
+    [super didMoveToWindow];
+    if (self.window && !self.isLayerAdded) {
+        [self findMapViewAndAddLayerInView:self.window];
+    }
+}
+
+- (void)layoutSubviews {
+    [super layoutSubviews];
+    
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+            if (!self.isLayerAdded) {
+                UIView *searchRoot = self.window ? self.window : self.superview;
+                if (searchRoot) {
+                    [self findMapViewAndAddLayerInView:searchRoot];
+                }
+            }
+        });
+    });
+}
+
+- (void)findMapViewAndAddLayerInView:(UIView *)view {
+    if (!view || self.isLayerAdded) {
+        return;
+    }
+
+    NSString *className = NSStringFromClass([view class]);
+    
+    if ([className isEqualToString:@"RNMBXMapView"]) {
+        if (view.subviews.count > 0) {
+            UIView *firstSubview = view.subviews[0];
+            NSString *subviewClass = NSStringFromClass([firstSubview class]);
+            if ([subviewClass containsString:@"MapboxMaps.MapView"] || [subviewClass isEqualToString:@"MapView"]) {
+                self.mapView = (MapView *)firstSubview;
+                [self waitForStyleLoadAndAddLayer];
+                return;
+            }
+        }
+        
+        RCTLogError(@"❌ [GridRenderLayerView] RNMBXMapView found but MapboxMaps.MapView not in expected location");
+        return;
+    }
+    
+    for (UIView *subview in view.subviews) {
+        [self findMapViewAndAddLayerInView:subview];
+        if (self.isLayerAdded) {
+            return;
+        }
+    }
+}
+
+- (void)waitForStyleLoadAndAddLayer {
+    if (!self.mapView) {
+        return;
+    }
+    
+    NSString *targetLayer = self.belowID ?: @"AML_-_terrain";
+    
+    // Check if the target layer already exists
+    if ([GridRenderLayerBridge layerExistsIn:self.mapView layerId:targetLayer]) {
+        [self addLayerToMap];
+        return;
+    }
+    
+    [self pollForLayerExistence];
+}
+
+- (void)pollForLayerExistence {
+    if (self.isLayerAdded || !self.mapView) {
+        return;
+    }
+    
+    NSString *targetLayer = self.belowID ?: @"AML_-_terrain";
+    
+    if ([GridRenderLayerBridge layerExistsIn:self.mapView layerId:targetLayer]) {
+        [self addLayerToMap];
+        return;
+    }
+    
+    // Try again in 100ms
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+        [self pollForLayerExistence];
+    });
+}
+
+- (void)addLayerToMap {
+    if (!self.mapView || self.isLayerAdded) {
+        return;
+    }
+    
+    id customLayer = [self.layerInstance getHostWrapper];
+    
+    if (!customLayer) {
+        RCTLogError(@"❌ [GridRenderLayerView] Failed to get hostWrapper");
+        return;
+    }
+    
+    BOOL success = [GridRenderLayerBridge addCustomLayerTo:self.mapView
+                                                 layerHost:customLayer
+                                                   layerId:self.layerId
+                                              belowLayerId:self.belowID];
+    
+    if (success) {
+        self.isLayerAdded = YES;
+
+        [[NSNotificationCenter defaultCenter] addObserverForName:@"TriggerMapRepaint"
+                                                        object:nil
+                                                            queue:[NSOperationQueue mainQueue]
+                                                    usingBlock:^(NSNotification *note) {
+            if (self.mapView) {
+                [GridRenderLayerBridge triggerRepaintOn:self.mapView];
+            }
+        }];
+    } else {
+        RCTLogError(@"❌ [GridRenderLayerView] Failed to add layer via Swift bridge");
+    }
+}
+
+- (void)removeFromSuperview {
+    if (self.mapView && self.isLayerAdded) {
+        id mapboxMap = [self.mapView valueForKey:@"mapboxMap"];
+        id style = [mapboxMap valueForKey:@"style"];
+        
+        SEL removeLayerSelector = NSSelectorFromString(@"removeStyleLayerWithIdentifier:completion:");
+        if ([style respondsToSelector:removeLayerSelector]) {
+            NSMethodSignature *signature = [style methodSignatureForSelector:removeLayerSelector];
+            NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
+            [invocation setTarget:style];
+            [invocation setSelector:removeLayerSelector];
+            
+            NSString *layerId = self.layerId;
+            [invocation setArgument:&layerId atIndex:2];
+            
+            id nilCompletion = nil;
+            [invocation setArgument:&nilCompletion atIndex:3];
+            [invocation invoke];
+        }
+    }
+    [super removeFromSuperview];
+}
+
+- (void)dealloc {
+    RCTLogInfo(@"🔴 [GridRenderLayerView] dealloc called");
+    
+    // Remove notification observer
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+    
+    // Clear the layer instance
+    if (_layerInstance) {
+        [_layerInstance clear];
+        _layerInstance = nil;
+    }
+    
+    _mapView = nil;
+}
+
+@end

package/lib/module/lib/commonjs/ios/InspectorDataCache.swift

@@ -0,0 +1,66 @@
+import Foundation
+
+final class InspectorDataCache {
+    static let shared = InspectorDataCache()
+    
+    private let queue = DispatchQueue(label: "com.aguacerowx.InspectorDataCacheQueue", attributes: .concurrent)
+    
+    private var _lastDecompressedData: Data?
+    private var _nx: Int = 0
+    private var _ny: Int = 0
+    private var _scale: Float = 1.0
+    private var _offset: Float = 0.0
+    private var _missing: Float = 127.0
+    private var _scaleType: Int = 0  // ADD THIS
+    
+    private init() {}
+    
+    var lastDecompressedData: Data? {
+        get { queue.sync { _lastDecompressedData } }
+    }
+    
+    var nx: Int {
+        get { queue.sync { _nx } }
+    }
+    
+    var ny: Int {
+        get { queue.sync { _ny } }
+    }
+    
+    var scale: Float {
+        get { queue.sync { _scale } }
+    }
+    
+    var offset: Float {
+        get { queue.sync { _offset } }
+    }
+    
+    var missing: Float {
+        get { queue.sync { _missing } }
+    }
+    
+    var scaleType: Int {  // ADD THIS
+        get { queue.sync { _scaleType } }
+    }
+    
+    func update(data: Data?, nx: Int, ny: Int, scale: Float, offset: Float, missing: Float, scaleType: Int = 0) {  // ADD scaleType parameter
+        queue.async(flags: .barrier) {
+            self._lastDecompressedData = data
+            self._nx = nx
+            self._ny = ny
+            self._scale = scale
+            self._offset = offset
+            self._missing = missing
+            self._scaleType = scaleType  // ADD THIS
+        }
+    }
+    
+    func clear() {
+        queue.async(flags: .barrier) {
+            self._lastDecompressedData = nil
+            self._nx = 0
+            self._ny = 0
+            self._scaleType = 0  // ADD THIS
+        }
+    }
+}

package/lib/module/lib/commonjs/ios/InspectorModule.m

@@ -0,0 +1,10 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(InspectorModule, NSObject)
+
+RCT_EXTERN_METHOD(getValueAtGridIndex:(nonnull NSNumber *)i
+                  j:(nonnull NSNumber *)j
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/lib/module/lib/commonjs/ios/InspectorModule.swift

@@ -0,0 +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 {
+                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
+    }
+}