@aguacerowx/react-native 0.0.41 → 0.0.42

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

@@ -0,0 +1,45 @@
+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
+        }
+    }
+
+    @objc public static func removeCustomLayer(from mapView: MapView, layerId: String) {
+        do {
+            try mapView.mapboxMap.removeLayer(withId: layerId)
+        } catch {
+            print("❌ [GridRenderLayerBridge] Failed to remove layer \(layerId): \(error)")
+        }
+    }
+}

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

@@ -0,0 +1,172 @@
+#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)
+{
+    NSTimeInterval start = [[NSDate date] timeIntervalSince1970];
+    NSUInteger len = [data length];
+    RCTLogInfo(@"⚡️ [PERF] [Bridge] updateDataTexture called. Payload: %lu chars", (unsigned long)len);
+
+    // OPTIMIZATION: Dispatch to a high-priority background queue immediately.
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
+        [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+            
+            NSTimeInterval uiBlockTime = [[NSDate date] timeIntervalSince1970];
+            RCTLogInfo(@"⚡️ [PERF] [Bridge] updateDataTexture dispatched in %.2f ms", (uiBlockTime - start) * 1000);
+
+            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)
+{
+    NSTimeInterval start = [[NSDate date] timeIntervalSince1970];
+    NSUInteger count = [frameInfo count];
+    RCTLogInfo(@"⚡️ [PERF] [Bridge] primeGpuCache called. Count: %lu", (unsigned long)count);
+
+    // OPTIMIZATION: Dispatch this immediately to a background thread to unblock JS.
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+            
+            NSTimeInterval uiBlockTime = [[NSDate date] timeIntervalSince1970];
+            RCTLogInfo(@"⚡️ [PERF] [Bridge] primeGpuCache handed to Swift in %.2f ms", (uiBlockTime - start) * 1000);
+
+            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,201 @@
+#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) {
+        [GridRenderLayerBridge removeCustomLayerFrom:self.mapView layerId:self.layerId];
+    }
+    [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,64 @@
+import Foundation
+
+final class InspectorDataCache {
+    static let shared = InspectorDataCache()
+    private let queue = DispatchQueue(label: "com.aguacerowx.InspectorDataCacheQueue", attributes: .concurrent)
+    
+    private var _filePath: String?
+    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
+
+    private init() {}
+
+    var filePath: String? { queue.sync { _filePath } }
+    var nx: Int { queue.sync { _nx } }
+    var ny: Int { queue.sync { _ny } }
+    var scale: Float { queue.sync { _scale } }
+    var offset: Float { queue.sync { _offset } }
+    var missing: Float { queue.sync { _missing } }
+    var scaleType: Int { queue.sync { _scaleType } }
+
+    // Keep this signature so existing callers don't break - just ignore the data param
+    func update(data: Data?, nx: Int, ny: Int, scale: Float, offset: Float, missing: Float, scaleType: Int = 0) {
+        queue.async(flags: .barrier) {
+            self._nx = nx
+            self._ny = ny
+            self._scale = scale
+            self._offset = offset
+            self._missing = missing
+            self._scaleType = scaleType
+        }
+    }
+
+    func updateFilePath(_ path: String) {
+        queue.async(flags: .barrier) {
+            self._filePath = path
+        }
+    }
+
+    // Convenience: update everything at once
+    func updateWithFilePath(filePath: String, nx: Int, ny: Int, scale: Float, offset: Float, missing: Float, scaleType: Int = 0) {
+        queue.async(flags: .barrier) {
+            self._filePath = filePath
+            self._nx = nx
+            self._ny = ny
+            self._scale = scale
+            self._offset = offset
+            self._missing = missing
+            self._scaleType = scaleType
+        }
+    }
+
+    func clear() {
+        queue.async(flags: .barrier) {
+            self._filePath = nil
+            self._nx = 0
+            self._ny = 0
+            self._scaleType = 0
+        }
+    }
+}

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