@aguacerowx/react-native 0.0.36 → 0.0.38

package/lib/commonjs/ios/InspectorModule.swift

@@ -1,64 +1,113 @@
-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
-    }
+import Foundation
+import React
+import libzstd
+
+@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 filePath = cache.filePath else {
+                resolve(nil)
+                return
+            }
+
+            let nx = cache.nx
+            let ny = cache.ny
+            let scale = cache.scale
+            let offset = cache.offset
+            let missing = cache.missing
+            let scaleType = cache.scaleType
+
+            let iVal = i.intValue
+            let jVal = j.intValue
+            let index = jVal * nx + iVal
+
+            guard index >= 0 && index < (nx * ny) else {
+                print("🔍 [Inspector] ERROR: Index out of bounds")
+                resolve(nil)
+                return
+            }
+
+            // Read and decompress the file
+            guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: filePath)) else {
+                print("🔍 [Inspector] ERROR: Could not read file at \(filePath)")
+                resolve(nil)
+                return
+            }
+
+            guard var decompressed = self.decompressZstd(data: fileData) else {
+                print("🔍 [Inspector] ERROR: Failed to decompress")
+                resolve(nil)
+                return
+            }
+
+            // Reconstruct delta encoding (same as GridRenderLayer)
+            self.reconstructInPlace(data: &decompressed)
+
+            guard index < decompressed.count else {
+                resolve(nil)
+                return
+            }
+
+            let rawByte = decompressed[index]
+            // After reconstructInPlace, bytes are raw signed values stored as UInt8
+            // The value is the signed Int8 interpretation
+            let signedQuantizedValue = Int(Int8(bitPattern: rawByte))
+            let missingQuantized = Int(round(missing))
+
+            if abs(signedQuantizedValue - missingQuantized) < 1 {
+                resolve(nil)
+                return
+            }
+
+            let intermediateValue = Double(signedQuantizedValue) * Double(scale) + Double(offset)
+            let finalValue = scaleType == 1 ? intermediateValue * abs(intermediateValue) : intermediateValue
+
+            resolve(finalValue)
+        }
+    }
+
+    // Reconstruct delta encoding only (no +128 shift, we want signed values)
+    private func reconstructInPlace(data: inout Data) {
+        let count = data.count
+        guard count > 0 else { return }
+        data.withUnsafeMutableBytes { rawBuffer in
+            guard let ptr = rawBuffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else { return }
+            var running = Int8(bitPattern: ptr[0])
+            // Leave ptr[0] as-is (it's already the first value)
+            for i in 1..<count {
+                let delta = Int8(bitPattern: ptr[i])
+                running = running &+ delta
+                ptr[i] = UInt8(bitPattern: running)
+            }
+        }
+    }
+
+    private func decompressZstd(data: Data) -> Data? {
+        let decompressedSize = data.withUnsafeBytes { ptr in
+            ZSTD_getFrameContentSize(ptr.baseAddress, data.count)
+        }
+        guard Int64(bitPattern: decompressedSize) > 0 else { return nil }
+
+        var decompressedData = Data(count: Int(decompressedSize))
+        let result = decompressedData.withUnsafeMutableBytes { decompPtr in
+            data.withUnsafeBytes { compPtr in
+                Int(ZSTD_decompress(decompPtr.baseAddress, Int(decompressedSize), compPtr.baseAddress, data.count))
+            }
+        }
+        guard result > 0 && result == decompressedData.count else { return nil }
+        return decompressedData
+    }
+
+    @objc
+    static func requiresMainQueueSetup() -> Bool { return false }
 }