@succinctlabs/react-native-zcam1 0.2.5

package/ios/Zcam1DepthData.swift

@@ -0,0 +1,417 @@
+//
+//  Zcam1DepthData.swift
+//  react-native-zcam1-sdk
+//
+//  Depth data extraction and processing using AVDepthData.
+//
+
+import AVFoundation
+import Foundation
+import ImageIO
+import UIKit
+
+// MARK: - Depth Data Processor
+
+/// Handles extraction, conversion, and serialization of depth data from AVDepthData.
+public class Zcam1DepthDataProcessor {
+
+    /// Extract depth data from an AVCapturePhoto if available.
+    /// Returns a dictionary containing depth information or nil if not available.
+    public static func extractDepthData(from photo: AVCapturePhoto) -> [String: Any]? {
+        guard let depthData = photo.depthData else {
+            return nil
+        }
+
+        return processDepthData(depthData)
+    }
+
+    /// Process AVDepthData and return a dictionary with depth information.
+    public static func processDepthData(_ depthData: AVDepthData) -> [String: Any] {
+        let depthDataMap = depthData.depthDataMap
+
+        // Get depth data dimensions
+        let width = CVPixelBufferGetWidth(depthDataMap)
+        let height = CVPixelBufferGetHeight(depthDataMap)
+
+        // Get pixel format type
+        let pixelFormatType = CVPixelBufferGetPixelFormatType(depthDataMap)
+        let pixelFormatString = pixelFormatTypeToString(pixelFormatType)
+
+        // Extract depth statistics
+        let statistics = extractDepthStatistics(from: depthDataMap)
+
+        // Get accuracy if available (iOS 14.1+)
+        var accuracyString = "relative"
+        if #available(iOS 14.1, *) {
+            switch depthData.depthDataAccuracy {
+            case .relative:
+                accuracyString = "relative"
+            case .absolute:
+                accuracyString = "absolute"
+            @unknown default:
+                accuracyString = "unknown"
+            }
+        }
+
+        var result: [String: Any] = [
+            "width": width,
+            "height": height,
+            "pixelFormat": pixelFormatString,
+            "statistics": statistics,
+            "accuracy": accuracyString,
+        ]
+
+        return result
+    }
+
+    /// Extract statistics (min, max, mean, stddev) from depth data.
+    ///
+    /// Computing stats over every pixel can be expensive and can delay photo capture completion,
+    /// especially when depth delivery is enabled. To keep capture responsive, this uses:
+    /// - adaptive sampling (caps work to ~65k pixels)
+    /// - a single-pass (Welford) accumulator (avoids large allocations)
+    private static func extractDepthStatistics(from depthDataMap: CVPixelBuffer) -> [String: Any] {
+        let width = CVPixelBufferGetWidth(depthDataMap)
+        let height = CVPixelBufferGetHeight(depthDataMap)
+        let pixelFormatType = CVPixelBufferGetPixelFormatType(depthDataMap)
+
+        // Cap work by sampling at most ~65k pixels.
+        let totalPixels = max(1, width * height)
+        let maxSamples = 65_536
+        let stride: Int = {
+            if totalPixels <= maxSamples { return 1 }
+            // Choose a stride so that (w/stride)*(h/stride) ~= maxSamples.
+            let scale = sqrt(Double(totalPixels) / Double(maxSamples))
+            return max(1, Int(scale.rounded(.up)))
+        }()
+
+        CVPixelBufferLockBaseAddress(depthDataMap, .readOnly)
+        defer { CVPixelBufferUnlockBaseAddress(depthDataMap, .readOnly) }
+
+        guard let baseAddress = CVPixelBufferGetBaseAddress(depthDataMap) else {
+            return [:]
+        }
+
+        let bytesPerRow = CVPixelBufferGetBytesPerRow(depthDataMap)
+
+        var count: Int = 0
+        var mean: Double = 0
+        var m2: Double = 0
+        var minValue: Float = .infinity
+        var maxValue: Float = -.infinity
+
+        func accumulate(_ v: Float) {
+            guard v.isFinite else { return }
+            count += 1
+            minValue = min(minValue, v)
+            maxValue = max(maxValue, v)
+
+            let x = Double(v)
+            let delta = x - mean
+            mean += delta / Double(count)
+            let delta2 = x - mean
+            m2 += delta * delta2
+        }
+
+        // Extract depth values based on pixel format (sampled).
+        switch pixelFormatType {
+        case kCVPixelFormatType_DepthFloat32, kCVPixelFormatType_DisparityFloat32:
+            let floatBuffer = baseAddress.assumingMemoryBound(to: Float32.self)
+            let rowStride = bytesPerRow / MemoryLayout<Float32>.stride
+            var y = 0
+            while y < height {
+                let rowBase = y * rowStride
+                var x = 0
+                while x < width {
+                    accumulate(floatBuffer[rowBase + x])
+                    x += stride
+                }
+                y += stride
+            }
+
+        case kCVPixelFormatType_DepthFloat16, kCVPixelFormatType_DisparityFloat16:
+            let float16Buffer = baseAddress.assumingMemoryBound(to: Float16.self)
+            let rowStride = bytesPerRow / MemoryLayout<Float16>.stride
+            var y = 0
+            while y < height {
+                let rowBase = y * rowStride
+                var x = 0
+                while x < width {
+                    accumulate(Float(float16Buffer[rowBase + x]))
+                    x += stride
+                }
+                y += stride
+            }
+
+        default:
+            break
+        }
+
+        // Calculate statistics
+        guard count > 0 else {
+            return [
+                "min": "",
+                "max": "",
+                "mean": "",
+                "stdDev": "",
+                "validPixelCount": 0,
+                "sampleStride": stride,
+            ]
+        }
+
+        let variance = m2 / Double(count)
+        let stdDev = sqrt(max(0, variance))
+
+        return [
+            "min": String(
+                format: "%.6f", locale: Locale(identifier: "en_US_POSIX"), Double(minValue)),
+            "max": String(
+                format: "%.6f", locale: Locale(identifier: "en_US_POSIX"), Double(maxValue)),
+            "mean": String(format: "%.6f", locale: Locale(identifier: "en_US_POSIX"), mean),
+            "stdDev": String(format: "%.6f", locale: Locale(identifier: "en_US_POSIX"), stdDev),
+            "validPixelCount": count,
+            "sampleStride": stride,
+        ]
+    }
+
+    /// Extract camera calibration data.
+    private static func extractCalibrationData(_ calibration: AVCameraCalibrationData) -> [String:
+        Any]
+    {
+        var result: [String: Any] = [:]
+
+        // Intrinsic matrix (3x3) - camera intrinsic parameters
+        // Intrinsic matrix (3x3)
+        let intrinsicMatrix = calibration.intrinsicMatrix
+        result["intrinsicMatrix"] = [
+            [intrinsicMatrix[0, 0], intrinsicMatrix[0, 1], intrinsicMatrix[0, 2]],
+            [intrinsicMatrix[1, 0], intrinsicMatrix[1, 1], intrinsicMatrix[1, 2]],
+            [intrinsicMatrix[2, 0], intrinsicMatrix[2, 1], intrinsicMatrix[2, 2]],
+        ]
+
+        // Extrinsic matrix (4x3)
+        let extrinsicMatrix = calibration.extrinsicMatrix
+        result["extrinsicMatrix"] = [
+            [extrinsicMatrix[0, 0], extrinsicMatrix[0, 1], extrinsicMatrix[0, 2]],
+            [extrinsicMatrix[1, 0], extrinsicMatrix[1, 1], extrinsicMatrix[1, 2]],
+            [extrinsicMatrix[2, 0], extrinsicMatrix[2, 1], extrinsicMatrix[2, 2]],
+            [extrinsicMatrix[3, 0], extrinsicMatrix[3, 1], extrinsicMatrix[3, 2]],
+        ]
+
+        // Lens distortion center
+        let lensDistortionCenter = calibration.lensDistortionCenter
+        result["lensDistortionCenter"] = [
+            "x": lensDistortionCenter.x,
+            "y": lensDistortionCenter.y,
+        ]
+
+        return result
+    }
+
+    /// Convert pixel format type to a human-readable string.
+    private static func pixelFormatTypeToString(_ pixelFormatType: OSType) -> String {
+        switch pixelFormatType {
+        case kCVPixelFormatType_DepthFloat32:
+            return "depthFloat32"
+        case kCVPixelFormatType_DepthFloat16:
+            return "depthFloat16"
+        case kCVPixelFormatType_DisparityFloat32:
+            return "disparityFloat32"
+        case kCVPixelFormatType_DisparityFloat16:
+            return "disparityFloat16"
+        default:
+            return "unknown"
+        }
+    }
+
+    /// Encode depth data as a grayscale image for visualization.
+    ///
+    /// The output is encoded to match Google's GDepth `RangeInverse` convention:
+    /// values are higher (brighter) for nearer pixels and lower (darker) for farther pixels.
+    public static func encodeDepthDataAsImage(
+        depthData: AVDepthData
+    ) -> UIImage? {
+        let depthDataMap = depthData.depthDataMap
+        let width = CVPixelBufferGetWidth(depthDataMap)
+        let height = CVPixelBufferGetHeight(depthDataMap)
+
+        CVPixelBufferLockBaseAddress(depthDataMap, .readOnly)
+        defer { CVPixelBufferUnlockBaseAddress(depthDataMap, .readOnly) }
+
+        guard let baseAddress = CVPixelBufferGetBaseAddress(depthDataMap) else {
+            return nil
+        }
+
+        let pixelFormatType = CVPixelBufferGetPixelFormatType(depthDataMap)
+        let bytesPerRow = CVPixelBufferGetBytesPerRow(depthDataMap)
+
+        // Extract depth values and find their range
+        var depthValues: [Float] = []
+        depthValues.reserveCapacity(width * height)
+        var minDepth: Float = .infinity
+        var maxDepth: Float = -.infinity
+
+        switch pixelFormatType {
+        case kCVPixelFormatType_DepthFloat32, kCVPixelFormatType_DisparityFloat32:
+            let floatBuffer = baseAddress.assumingMemoryBound(to: Float32.self)
+            for y in 0..<height {
+                for x in 0..<width {
+                    let offset = y * (bytesPerRow / MemoryLayout<Float32>.stride) + x
+                    let value = floatBuffer[offset]
+                    if !value.isNaN && !value.isInfinite {
+                        depthValues.append(value)
+                        // Ignore non-positive values when establishing near/far planes,
+                        // since RangeInverse uses 1/depth.
+                        if value > 0 {
+                            minDepth = min(minDepth, value)
+                            maxDepth = max(maxDepth, value)
+                        }
+                    }
+                }
+            }
+
+        case kCVPixelFormatType_DepthFloat16, kCVPixelFormatType_DisparityFloat16:
+            let float16Buffer = baseAddress.assumingMemoryBound(to: Float16.self)
+            for y in 0..<height {
+                for x in 0..<width {
+                    let offset = y * (bytesPerRow / MemoryLayout<Float16>.stride) + x
+                    let value = Float(float16Buffer[offset])
+                    if !value.isNaN && !value.isInfinite {
+                        depthValues.append(value)
+                        // Ignore non-positive values when establishing near/far planes,
+                        // since RangeInverse uses 1/depth.
+                        if value > 0 {
+                            minDepth = min(minDepth, value)
+                            maxDepth = max(maxDepth, value)
+                        }
+                    }
+                }
+            }
+
+        default:
+            return nil
+        }
+
+        // Create grayscale image from normalized depth data
+        guard !depthValues.isEmpty else { return nil }
+
+        // If we never saw any positive finite values, near/far planes are not usable.
+        if !minDepth.isFinite || !maxDepth.isFinite || minDepth <= 0 || maxDepth <= 0 {
+            minDepth = 0
+            maxDepth = 0
+        }
+
+        let depthRange = maxDepth - minDepth
+        var pixelData = [UInt8]()
+        pixelData.reserveCapacity(width * height)
+
+        switch pixelFormatType {
+        case kCVPixelFormatType_DepthFloat32, kCVPixelFormatType_DisparityFloat32:
+            let floatBuffer = baseAddress.assumingMemoryBound(to: Float32.self)
+            for y in 0..<height {
+                for x in 0..<width {
+                    let offset = y * (bytesPerRow / MemoryLayout<Float32>.stride) + x
+                    let value = floatBuffer[offset]
+                    if value.isNaN || value.isInfinite || value <= 0 {
+                        pixelData.append(0)
+                        continue
+                    }
+
+                    // RangeInverse: normalize in inverse-depth space (1/z), so nearer pixels are brighter.
+                    let normalized: Float
+                    if depthRange > 0, minDepth > 0, maxDepth > 0 {
+                        let inv = 1.0 / value
+                        let invNear = 1.0 / minDepth
+                        let invFar = 1.0 / maxDepth
+                        let invRange = invNear - invFar
+
+                        if inv.isFinite, invNear.isFinite, invFar.isFinite, invRange != 0 {
+                            normalized = (inv - invFar) / invRange
+                        } else {
+                            normalized = 0
+                        }
+                    } else {
+                        normalized = 0
+                    }
+
+                    if !normalized.isFinite {
+                        pixelData.append(0)
+                    } else {
+                        let clamped = max(0, min(1, normalized))
+                        pixelData.append(UInt8(max(0, min(255, clamped * 255))))
+                    }
+                }
+            }
+
+        case kCVPixelFormatType_DepthFloat16, kCVPixelFormatType_DisparityFloat16:
+            let float16Buffer = baseAddress.assumingMemoryBound(to: Float16.self)
+            for y in 0..<height {
+                for x in 0..<width {
+                    let offset = y * (bytesPerRow / MemoryLayout<Float16>.stride) + x
+                    let value = Float(float16Buffer[offset])
+                    if value.isNaN || value.isInfinite || value <= 0 {
+                        pixelData.append(0)
+                        continue
+                    }
+
+                    // RangeInverse: normalize in inverse-depth space (1/z), so nearer pixels are brighter.
+                    let normalized: Float
+                    if depthRange > 0, minDepth > 0, maxDepth > 0 {
+                        let inv = 1.0 / value
+                        let invNear = 1.0 / minDepth
+                        let invFar = 1.0 / maxDepth
+                        let invRange = invNear - invFar
+
+                        if inv.isFinite, invNear.isFinite, invFar.isFinite, invRange != 0 {
+                            normalized = (inv - invFar) / invRange
+                        } else {
+                            normalized = 0
+                        }
+                    } else {
+                        normalized = 0
+                    }
+
+                    if !normalized.isFinite {
+                        pixelData.append(0)
+                    } else {
+                        let clamped = max(0, min(1, normalized))
+                        pixelData.append(UInt8(max(0, min(255, clamped * 255))))
+                    }
+                }
+            }
+
+        default:
+            return nil
+        }
+
+        // Create CGImage from pixel data
+        guard
+            let provider = CGDataProvider(
+                data: NSData(bytes: pixelData, length: pixelData.count))
+        else {
+            return nil
+        }
+
+        let colorSpace = CGColorSpaceCreateDeviceGray()
+        guard
+            let cgImage = CGImage(
+                width: width,
+                height: height,
+                bitsPerComponent: 8,
+                bitsPerPixel: 8,
+                bytesPerRow: width,
+                space: colorSpace,
+                bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.none.rawValue),
+                provider: provider,
+                decode: nil,
+                shouldInterpolate: false,
+                intent: .defaultIntent
+            )
+        else {
+            return nil
+        }
+
+        return UIImage(cgImage: cgImage)
+    }
+
+}

package/ios/Zcam1Sdk.h

@@ -0,0 +1,16 @@
+// Generated by uniffi-bindgen-react-native
+#ifdef __cplusplus
+#import "zcam1-sdk.h"
+#endif
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "Zcam1SdkSpec.h"
+
+@interface Zcam1Sdk : NSObject <NativeZcam1SdkSpec>
+#else
+#import <React/RCTBridgeModule.h>
+
+@interface Zcam1Sdk : NSObject <RCTBridgeModule>
+#endif
+
+@end

package/ios/Zcam1Sdk.mm

@@ -0,0 +1,66 @@
+// Generated by uniffi-bindgen-react-native
+#import "Zcam1Sdk.h"
+
+namespace uniffi_generated {
+    using namespace facebook::react;
+    /**
+    * ObjC++ class for module 'NativeZcam1Sdk'
+    */
+    class JSI_EXPORT NativeZcam1SdkSpecJSI : public ObjCTurboModule {
+    public:
+        NativeZcam1SdkSpecJSI(const ObjCTurboModule::InitParams &params);
+        std::shared_ptr<CallInvoker> callInvoker;
+    };
+
+    static facebook::jsi::Value __hostFunction_Zcam1Sdk_installRustCrate(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+        auto& tm = static_cast<NativeZcam1SdkSpecJSI&>(turboModule);
+        auto jsInvoker = tm.callInvoker;
+        uint8_t result = zcam1sdk::installRustCrate(rt, jsInvoker);
+        return facebook::jsi::Value(rt, result);
+    }
+    static facebook::jsi::Value __hostFunction_Zcam1Sdk_cleanupRustCrate(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+        uint8_t result = zcam1sdk::cleanupRustCrate(rt);
+        return facebook::jsi::Value(rt, result);
+    }
+
+    NativeZcam1SdkSpecJSI::NativeZcam1SdkSpecJSI(const ObjCTurboModule::InitParams &params)
+        : ObjCTurboModule(params), callInvoker(params.jsInvoker) {
+            this->methodMap_["installRustCrate"] = MethodMetadata {1, __hostFunction_Zcam1Sdk_installRustCrate};
+            this->methodMap_["cleanupRustCrate"] = MethodMetadata {1, __hostFunction_Zcam1Sdk_cleanupRustCrate};
+    }
+} // namespace uniffi_generated
+
+@implementation Zcam1Sdk
+RCT_EXPORT_MODULE()
+
+// Don't compile this code when we build for the old architecture.
+#ifdef RCT_NEW_ARCH_ENABLED
+
+// Automated testing checks zcam1sdk
+// by comparing the whole line here.
+/*
+- (NSNumber *)multiply:(double)a b:(double)b {
+    NSNumber *result = @(zcam1sdk::multiply(a, b));
+}
+*/
+
+- (NSNumber *)installRustCrate {
+    @throw [NSException exceptionWithName:@"UnreachableException"
+                        reason:@"This method should never be called."
+                        userInfo:nil];
+}
+
+- (NSNumber *)cleanupRustCrate {
+    @throw [NSException exceptionWithName:@"UnreachableException"
+                        reason:@"This method should never be called."
+                        userInfo:nil];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<uniffi_generated::NativeZcam1SdkSpecJSI>(params);
+}
+#endif
+
+@end

package/ios/proving/Zcam1Proving.h

@@ -0,0 +1,16 @@
+// Generated by uniffi-bindgen-react-native
+#ifdef __cplusplus
+#import "zcam1-proving.h"
+#endif
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "Zcam1SdkSpec.h"
+
+@interface Zcam1Proving : NSObject <NativeZcam1ProvingSpec>
+#else
+#import <React/RCTBridgeModule.h>
+
+@interface Zcam1Proving : NSObject <RCTBridgeModule>
+#endif
+
+@end

package/ios/proving/Zcam1Proving.mm

@@ -0,0 +1,66 @@
+// Generated by uniffi-bindgen-react-native
+#import "Zcam1Proving.h"
+
+namespace uniffi_generated {
+    using namespace facebook::react;
+    /**
+    * ObjC++ class for module 'NativeZcam1Proving'
+    */
+    class JSI_EXPORT NativeZcam1ProvingSpecJSI : public ObjCTurboModule {
+    public:
+        NativeZcam1ProvingSpecJSI(const ObjCTurboModule::InitParams &params);
+        std::shared_ptr<CallInvoker> callInvoker;
+    };
+
+    static facebook::jsi::Value __hostFunction_Zcam1Proving_installRustCrate(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+        auto& tm = static_cast<NativeZcam1ProvingSpecJSI&>(turboModule);
+        auto jsInvoker = tm.callInvoker;
+        uint8_t result = zcam1proving::installRustCrate(rt, jsInvoker);
+        return facebook::jsi::Value(rt, result);
+    }
+    static facebook::jsi::Value __hostFunction_Zcam1Proving_cleanupRustCrate(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+        uint8_t result = zcam1proving::cleanupRustCrate(rt);
+        return facebook::jsi::Value(rt, result);
+    }
+
+    NativeZcam1ProvingSpecJSI::NativeZcam1ProvingSpecJSI(const ObjCTurboModule::InitParams &params)
+        : ObjCTurboModule(params), callInvoker(params.jsInvoker) {
+            this->methodMap_["installRustCrate"] = MethodMetadata {1, __hostFunction_Zcam1Proving_installRustCrate};
+            this->methodMap_["cleanupRustCrate"] = MethodMetadata {1, __hostFunction_Zcam1Proving_cleanupRustCrate};
+    }
+} // namespace uniffi_generated
+
+@implementation Zcam1Proving
+RCT_EXPORT_MODULE()
+
+// Don't compile this code when we build for the old architecture.
+#ifdef RCT_NEW_ARCH_ENABLED
+
+// Automated testing checks zcam1proving
+// by comparing the whole line here.
+/*
+- (NSNumber *)multiply:(double)a b:(double)b {
+    NSNumber *result = @(zcam1proving::multiply(a, b));
+}
+*/
+
+- (NSNumber *)installRustCrate {
+    @throw [NSException exceptionWithName:@"UnreachableException"
+                        reason:@"This method should never be called."
+                        userInfo:nil];
+}
+
+- (NSNumber *)cleanupRustCrate {
+    @throw [NSException exceptionWithName:@"UnreachableException"
+                        reason:@"This method should never be called."
+                        userInfo:nil];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<uniffi_generated::NativeZcam1ProvingSpecJSI>(params);
+}
+#endif
+
+@end

package/lib/module/NativeZcam1Capture.js

@@ -0,0 +1,12 @@
+"use strict";
+
+import { TurboModuleRegistry } from "react-native";
+
+/**
+ * Physical device orientation as reported by the accelerometer.
+ * Unlike Orientation (which is a capture setting), this reflects the
+ * actual device position and is emitted via onOrientationChange events.
+ */
+
+export default TurboModuleRegistry.getEnforcing("Zcam1Capture");
+//# sourceMappingURL=NativeZcam1Capture.js.map

package/lib/module/NativeZcam1Capture.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeZcam1Capture.ts"],"mappings":";;AAAA,SAA2BA,mBAAmB,QAAQ,cAAc;;AA8JpE;AACA;AACA;AACA;AACA;;AA4KA,eAAeA,mBAAmB,CAACC,YAAY,CAAO,cAAc,CAAC","ignoreList":[]}

package/lib/module/NativeZcam1Sdk.js

@@ -0,0 +1,7 @@
+"use strict";
+
+// Generated by uniffi-bindgen-react-native
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('Zcam1Sdk');
+//# sourceMappingURL=NativeZcam1Sdk.js.map

package/lib/module/NativeZcam1Sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeZcam1Sdk.ts"],"mappings":";;AAAA;;AAEA,SAASA,mBAAmB,QAAQ,cAAc;AAOlD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,UAAU,CAAC","ignoreList":[]}

package/lib/module/bindings.js

@@ -0,0 +1,51 @@
+"use strict";
+
+// Generated by uniffi-bindgen-react-native
+import installer from "./NativeZcam1Sdk.js";
+
+// Register the rust crate with Hermes
+// - the boolean flag ensures this loads exactly once, even if the JS
+//   code is reloaded (e.g. during development with metro).
+let rustInstalled = false;
+if (!rustInstalled) {
+  installer.installRustCrate();
+  rustInstalled = true;
+}
+
+// Export the generated bindings to the app.
+export * from "./generated/zcam1_c2pa_utils.js";
+export * from "./generated/zcam1_certs_utils.js";
+export * from "./generated/zcam1_verify_utils.js";
+
+// Now import the bindings so we can:
+// - intialize them
+// - export them as namespaced objects as the default export.
+import * as zcam1_c2pa_utils from "./generated/zcam1_c2pa_utils.js";
+import * as zcam1_certs_utils from "./generated/zcam1_certs_utils.js";
+import * as zcam1_verify_utils from "./generated/zcam1_verify_utils.js";
+
+// Initialize the generated bindings: mostly checksums, but also callbacks.
+// - the boolean flag ensures this loads exactly once, even if the JS code
+//   is reloaded (e.g. during development with metro).
+let initialized = false;
+if (!initialized) {
+  zcam1_c2pa_utils.default.initialize();
+  zcam1_certs_utils.default.initialize();
+  zcam1_verify_utils.default.initialize();
+  initialized = true;
+}
+
+// This provides parity with the index.web.ts version of this file.
+// The web version relies on an asynchronous fetch, which this doesn't
+// need, so we just no-op.
+export async function uniffiInitAsync() {
+  // NOOP.
+}
+
+// Export the crates as individually namespaced objects.
+export default {
+  zcam1_c2pa_utils,
+  zcam1_certs_utils,
+  zcam1_verify_utils
+};
+//# sourceMappingURL=bindings.js.map

package/lib/module/bindings.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["installer","rustInstalled","installRustCrate","zcam1_c2pa_utils","zcam1_certs_utils","zcam1_verify_utils","initialized","default","initialize","uniffiInitAsync"],"sourceRoot":"../../src","sources":["bindings.tsx"],"mappings":";;AAAA;AACA,OAAOA,SAAS,MAAM,qBAAkB;;AAExC;AACA;AACA;AACA,IAAIC,aAAa,GAAG,KAAK;AACzB,IAAI,CAACA,aAAa,EAAE;EAClBD,SAAS,CAACE,gBAAgB,CAAC,CAAC;EAC5BD,aAAa,GAAG,IAAI;AACtB;;AAEA;AACA,cAAc,iCAA8B;AAC5C,cAAc,kCAA+B;AAC7C,cAAc,mCAAgC;;AAE9C;AACA;AACA;AACA,OAAO,KAAKE,gBAAgB,MAAM,iCAA8B;AAChE,OAAO,KAAKC,iBAAiB,MAAM,kCAA+B;AAClE,OAAO,KAAKC,kBAAkB,MAAM,mCAAgC;;AAEpE;AACA;AACA;AACA,IAAIC,WAAW,GAAG,KAAK;AACvB,IAAI,CAACA,WAAW,EAAE;EAChBH,gBAAgB,CAACI,OAAO,CAACC,UAAU,CAAC,CAAC;EACrCJ,iBAAiB,CAACG,OAAO,CAACC,UAAU,CAAC,CAAC;EACtCH,kBAAkB,CAACE,OAAO,CAACC,UAAU,CAAC,CAAC;EACvCF,WAAW,GAAG,IAAI;AACpB;;AAEA;AACA;AACA;AACA,OAAO,eAAeG,eAAeA,CAAA,EAAG;EACtC;AAAA;;AAGF;AACA,eAAe;EACbN,gBAAgB;EAChBC,iBAAiB;EACjBC;AACF,CAAC","ignoreList":[]}