@aguacerowx/react-native 0.0.8 → 0.0.9

package/ios/GridRenderLayerBridge.swift

@@ -0,0 +1,30 @@
+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) }
+        
+        // Create a CustomLayer object
+        var customLayer = CustomLayer(id: layerId, renderer: layerHost)
+        
+        do {
+            try mapView.mapboxMap.addLayer(customLayer, layerPosition: position)
+            print("✅ [GridRenderLayerBridge] Successfully added custom layer!")
+            return true
+        } catch {
+            print("❌ [GridRenderLayerBridge] Failed to add layer: \(error)")
+            return false
+        }
+    }
+
+    @objc public static func triggerRepaint(on mapView: MapView) {
+        mapView.mapboxMap.triggerRepaint()
+    }
+}

package/ios/GridRenderLayerManager.mm

@@ -1,140 +1,146 @@
 #import <React/RCTViewManager.h>
 #import <React/RCTUIManager.h>
 #import <React/RCTLog.h>
+#import "GridRenderLayerView.h"
 
-// This import uses the module name from your podspec `aguacerowx-react-native` -> `aguacerowx_react_native`).
-#import <aguacerowx_react_native/aguacerowx_react_native-Swift.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
 
-- (instancetype)init
-{
-    self = [super init];
-    if (self) {
-        RCTLogInfo(@"🔵 [GridRenderLayerManager] INIT CALLED");
-        NSLog(@"🔵 [GridRenderLayerManager] ✅✅✅ GridRenderLayerManager INITIALIZED ✅✅✅");
-    }
-    return self;
+RCT_EXPORT_MODULE(GridRenderLayer)
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
 }
 
-+ (void)load
-{
-    RCTLogInfo(@"🔵 [GridRenderLayerManager] CLASS LOAD CALLED");
-    NSLog(@"🔵 [GridRenderLayerManager] Class is being loaded into runtime");
+- (UIView *)view {
+    return [[GridRenderLayerView alloc] init];
 }
 
-// Export the module - this is what registers "GridRenderLayer" with React Native
-RCT_EXPORT_MODULE(GridRenderLayerManager)
+// --- 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)
 
-+ (BOOL)requiresMainQueueSetup
+// --- Commands ---
+RCT_EXPORT_METHOD(updateGeometry:(nonnull NSNumber *)reactTag
+                  corners:(NSDictionary *)corners
+                  gridDef:(NSDictionary *)gridDef)
 {
-    RCTLogInfo(@"🔵 [GridRenderLayerManager] requiresMainQueueSetup called - returning YES");
-    return YES;
+    // 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];
+            }
+        }];
+    });
 }
 
-// This creates the actual view
-- (UIView *)view
+
+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)
 {
-    RCTLogInfo(@"🔵 [GridRenderLayerManager] view() method called - creating GridRenderLayer instance");
-    NSLog(@"🔵 [GridRenderLayerManager] Creating new GridRenderLayer view");
-    
-    GridRenderLayer *gridView = [[GridRenderLayer alloc] init];
-    NSLog(@"🔵 [GridRenderLayerManager] GridRenderLayer created: %@", gridView);
-    
-    return gridView;
+    // 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];
+            }
+        }];
+    });
 }
 
-// Export properties
-RCT_EXPORT_VIEW_PROPERTY(opacity, float)
-RCT_EXPORT_VIEW_PROPERTY(dataRange, NSArray)
-RCT_EXPORT_VIEW_PROPERTY(belowID, NSString)
-RCT_EXPORT_VIEW_PROPERTY(smoothing, BOOL)
-
-// Log when properties are set
-- (void)setBridge:(RCTBridge *)bridge
+RCT_EXPORT_METHOD(updateColormapTexture:(nonnull NSNumber *)reactTag
+                  colormapAsBase64:(NSString *)colormapAsBase64)
 {
-    [super setBridge:bridge];
-    RCTLogInfo(@"🔵 [GridRenderLayerManager] Bridge set: %@", bridge);
-    NSLog(@"🔵 [GridRenderLayerManager] Bridge connected successfully");
+    // 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];
+            }
+        }];
+    });
 }
 
-// Export commands for Fabric
-RCT_EXPORT_VIEW_MANAGER_COMMAND(updateGeometry, {
-    RCTLogInfo(@"🟢 [GridRenderLayerManager] updateGeometry command received");
-    NSLog(@"🟢 [GridRenderLayerManager] updateGeometry - node: %@, args: %@", node, args);
-    
+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) {
-        UIView *view = viewRegistry[node];
-        NSLog(@"🟢 [GridRenderLayerManager] updateGeometry - found view: %@", view);
-        
-        if (![view isKindOfClass:[GridRenderLayer class]]) {
-            RCTLogError(@"🔴 [GridRenderLayerManager] ERROR: Expected GridRenderLayer but got: %@", [view class]);
-        } else {
-            NSDictionary *corners = args[0];
-            NSDictionary *gridDef = args[1];
-            NSLog(@"🟢 [GridRenderLayerManager] updateGeometry - calling Swift method with corners: %@, gridDef: %@", corners, gridDef);
-            [(GridRenderLayer *)view updateGeometryWithCorners:corners gridDef:gridDef];
+        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_VIEW_MANAGER_COMMAND(updateDataTexture, {
-    RCTLogInfo(@"🟢 [GridRenderLayerManager] updateDataTexture command received");
-    NSLog(@"🟢 [GridRenderLayerManager] updateDataTexture - node: %@, args count: %lu", node, (unsigned long)[args count]);
-    
+RCT_EXPORT_METHOD(clear:(nonnull NSNumber *)reactTag)
+{
     [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-        UIView *view = viewRegistry[node];
-        if ([view isKindOfClass:[GridRenderLayer class]]) {
-            NSString *data = args[0];
-            NSNumber *nx = args[1];
-            NSNumber *ny = args[2];
-            NSNumber *scale = args[3];
-            NSNumber *offset = args[4];
-            NSNumber *missing = args[5];
-            NSLog(@"🟢 [GridRenderLayerManager] updateDataTexture - calling Swift method");
-            [(GridRenderLayer *)view updateDataTextureWithData:data nx:nx ny:ny scale:scale offset:offset missing:missing];
-        } else {
-            RCTLogError(@"🔴 [GridRenderLayerManager] updateDataTexture - wrong view type: %@", [view class]);
+        GridRenderLayerView *view = (GridRenderLayerView *)viewRegistry[reactTag];
+        if ([view isKindOfClass:[GridRenderLayerView class]]) {
+            [view.layerInstance clear];
         }
     }];
-})
+}
 
-RCT_EXPORT_VIEW_MANAGER_COMMAND(updateColormapTexture, {
-    RCTLogInfo(@"🟢 [GridRenderLayerManager] updateColormapTexture command received");
+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) {
-        UIView *view = viewRegistry[node];
-        if ([view isKindOfClass:[GridRenderLayer class]]) {
-            NSString *colormapAsBase64 = args[0];
-            [(GridRenderLayer *)view updateColormapTextureWithColormapAsBase64:colormapAsBase64];
+        GridRenderLayerView *view = (GridRenderLayerView *)viewRegistry[reactTag];
+        if ([view isKindOfClass:[GridRenderLayerView class]]) {
+            [view.layerInstance setActiveFrameWithCacheKey:cacheKey];
         }
     }];
-})
+}
 
-RCT_EXPORT_VIEW_MANAGER_COMMAND(updateDataParameters, {
-    RCTLogInfo(@"🟢 [GridRenderLayerManager] updateDataParameters command received");
+RCT_EXPORT_METHOD(clearGpuCache:(nonnull NSNumber *)reactTag)
+{
     [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-        UIView *view = viewRegistry[node];
-        if ([view isKindOfClass:[GridRenderLayer class]]) {
-            NSNumber *scale = args[0];
-            NSNumber *offset = args[1];
-            NSNumber *missing = args[2];
-            [(GridRenderLayer *)view updateDataParametersWithScale:scale offset:offset missing:missing];
+        GridRenderLayerView *view = (GridRenderLayerView *)viewRegistry[reactTag];
+        if ([view isKindOfClass:[GridRenderLayerView class]]) {
+            [view.layerInstance clearGpuCache];
         }
     }];
-})
-
-// Override to log module constants
-- (NSDictionary *)constantsToExport
-{
-    NSDictionary *constants = @{
-        @"ComponentName": @"GridRenderLayer",
-        @"ModuleName": @"GridRenderLayerManager"
-    };
-    RCTLogInfo(@"🔵 [GridRenderLayerManager] constantsToExport: %@", constants);
-    return constants;
 }
 
 @end

package/ios/GridRenderLayerView.h

@@ -0,0 +1,23 @@
+#import <UIKit/UIKit.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;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/GridRenderLayerView.m

@@ -0,0 +1,199 @@
+#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;
+        RCTLogInfo(@"🟢 [GridRenderLayerView] Initialized with layer ID: %@", _layerId);
+    }
+    return self;
+}
+
++ (void)load {
+    RCTLogInfo(@"🔵 GridRenderLayerView IS LOADED INTO RUNTIME 🔵");
+    NSLog(@"🔵 GridRenderLayerView IS LOADED INTO RUNTIME 🔵");
+}
+
+#pragma mark - Property Setters
+
+- (void)setOpacity:(float)opacity {
+    [self.layerInstance setOpacityWithValue:opacity];
+    RCTLogInfo(@"🟢 [GridRenderLayerView] Set opacity: %f", opacity);
+}
+
+- (void)setDataRange:(NSArray *)dataRange {
+    if (dataRange && dataRange.count == 2) {
+        [self.layerInstance setDataRangeWithValue:dataRange];
+        RCTLogInfo(@"🟢 [GridRenderLayerView] Set data range: %@", dataRange);
+    } else {
+        RCTLogError(@"❌ [GridRenderLayerView] Invalid dataRange: %@", dataRange);
+    }
+}
+
+- (void)setSmoothing:(BOOL)smoothing {
+    [self.layerInstance setSmoothingWithValue:smoothing];
+    RCTLogInfo(@"🟢 [GridRenderLayerView] Set smoothing: %d", smoothing);
+}
+
+- (void)setBelowID:(NSString *)belowID {
+    _belowID = belowID;
+    RCTLogInfo(@"🟢 [GridRenderLayerView] Set belowID: %@", belowID);
+}
+
+#pragma mark - View Lifecycle
+
+- (void)didMoveToWindow {
+    [super didMoveToWindow];
+    if (self.window && !self.isLayerAdded) {
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+            [self findMapViewAndAddLayerInView:self.window]; // Start from window, not superview
+        });
+    }
+}
+
+- (void)findMapViewAndAddLayerInView:(UIView *)view {
+    if (!view || self.isLayerAdded) {
+        return;
+    }
+    
+    NSString *className = NSStringFromClass([view class]);
+    
+    // Check if this is RNMBXMapView - the wrapper
+    if ([className isEqualToString:@"RNMBXMapView"]) {
+        RCTLogInfo(@"✅ [GridRenderLayerView] Found RNMBXMapView!");
+        
+        // The first subview should be MapboxMaps.MapView
+        if (view.subviews.count > 0) {
+            UIView *firstSubview = view.subviews[0];
+            NSString *subviewClass = NSStringFromClass([firstSubview class]);
+            RCTLogInfo(@"   🔎 First subview is: %@", subviewClass);
+            
+            if ([subviewClass containsString:@"MapboxMaps.MapView"] || [subviewClass isEqualToString:@"MapView"]) {
+                RCTLogInfo(@"✅ [GridRenderLayerView] Found actual MapboxMaps.MapView!");
+                self.mapView = (MapView *)firstSubview;
+                [self addLayerToMap];
+                return;
+            }
+        }
+        
+        RCTLogError(@"❌ [GridRenderLayerView] RNMBXMapView found but MapboxMaps.MapView not in expected location");
+        return;
+    }
+    
+    // Recursively search all subviews
+    for (UIView *subview in view.subviews) {
+        [self findMapViewAndAddLayerInView:subview];
+        if (self.isLayerAdded) {
+            return;
+        }
+    }
+}
+
+- (void)logViewHierarchy:(UIView *)view depth:(int)depth {
+    NSString *indent = [@"" stringByPaddingToLength:depth * 2 withString:@" " startingAtIndex:0];
+    NSString *className = NSStringFromClass([view class]);
+    RCTLogInfo(@"%@└─ %@", indent, className);
+    
+    for (UIView *subview in view.subviews) {
+        [self logViewHierarchy:subview depth:depth + 1];
+    }
+}
+
+- (void)addLayerToMap {
+    if (!self.mapView || self.isLayerAdded) {
+        return;
+    }
+    
+    RCTLogInfo(@"🟡 [GridRenderLayerView] Attempting to add layer via Swift bridge");
+    
+    id customLayer = [self.layerInstance getHostWrapper];
+    
+    if (!customLayer) {
+        RCTLogError(@"❌ [GridRenderLayerView] Failed to get hostWrapper");
+        return;
+    }
+    
+    // Get the mapboxMap property using runtime
+    Ivar mapboxMapIvar = class_getInstanceVariable([self.mapView class], "mapboxMap");
+    if (!mapboxMapIvar) {
+        RCTLogError(@"❌ [GridRenderLayerView] Could not find mapboxMap ivar");
+        return;
+    }
+    
+    id mapboxMap = object_getIvar(self.mapView, mapboxMapIvar);
+    if (!mapboxMap) {
+        RCTLogError(@"❌ [GridRenderLayerView] mapboxMap is nil");
+        return;
+    }
+    
+    // Use the Swift bridge to add the layer
+    BOOL success = [GridRenderLayerBridge addCustomLayerTo:self.mapView
+                                                 layerHost:customLayer
+                                                   layerId:self.layerId
+                                              belowLayerId:self.belowID];
+    
+    if (success) {
+        self.isLayerAdded = YES;
+        RCTLogInfo(@"🎉 [GridRenderLayerView] Successfully added layer via Swift bridge!");
+
+        [[NSNotificationCenter defaultCenter] addObserverForName:@"TriggerMapRepaint"
+                                                        object:nil
+                                                            queue:[NSOperationQueue mainQueue]
+                                                    usingBlock:^(NSNotification *note) {
+            RCTLogInfo(@"🔄 [GridRenderLayerView] Received repaint notification");
+            if (self.mapView) {
+                RCTLogInfo(@"   ✅ Calling Swift bridge triggerRepaint");
+                [GridRenderLayerBridge triggerRepaintOn:self.mapView];
+                RCTLogInfo(@"   ✅ Called triggerRepaint via Swift bridge");
+            }
+        }];
+    } 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];
+            
+            RCTLogInfo(@"🟢 [GridRenderLayerView] Removed custom layer: %@", self.layerId);
+        }
+    }
+    [super removeFromSuperview];
+}
+
+@end

package/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/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/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 {
+                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
+    }
+}