@imgly/camera-react-native 1.81.1 → 1.82.0-rc.1

package/IMGLYCameraModule.podspec

@@ -14,6 +14,9 @@ Pod::Spec.new do |s|
   s.source          = { path: './ios' }
 
   s.source_files    = 'ios/**/*.{h,m,mm,swift}'
+  # ios/Package.swift is the manifest for React Native's experimental Swift
+  # Package Manager mode, not a source file.
+  s.exclude_files   = 'ios/Package.swift'
 
   s.dependency 'IMGLYCamera', s.version.to_s
 

package/README.md

@@ -24,3 +24,20 @@ const result = await IMGLYCamera.openCamera({
 ## Changelog
 
 To keep up-to-date with the latest changes, visit [CHANGELOG](https://img.ly/docs/cesdk/changelog/).
+
+## Swift Package Manager (experimental)
+
+React Native 0.87 introduced an experimental Swift Package Manager mode (`npx react-native spm`) — see the [React Native 0.87 announcement](https://reactnative.dev/blog/2026/08/11/react-native-0.87) and the [0.87.0 release notes](https://github.com/react/react-native/releases/tag/v0.87.0). This module dual-ships a SwiftPM manifest (`ios/Package.swift`) next to its podspec, so React Native's SPM autolinking resolves it out of the box. CocoaPods currently remains the default integration path; the React Native team does not recommend the SPM mode for production yet.
+
+The notes below describe React Native **0.87.0**. That is the version this
+support was built and verified against. We have not verified newer React Native
+versions, so we do not know whether these workarounds still apply there. React
+Native calls this mode experimental and can change its commands, flags, and
+generated layout in any release. Check the release notes of the React Native
+version you use.
+
+Note: React Native 0.87 pins its generated autolinking package to iOS 15 while this module requires iOS 16. Until the floor is derived from the linked libraries upstream, raise the `platforms:` entries in `react-native/scripts/spm/generate-spm-autolinking.js` to `.iOS(.v16)` (for example with `patch-package`).
+
+Note: The app target itself must also build with an iOS 16 deployment target. The React Native template scaffolds a lower one, which works until your app code imports this module directly — for example for native customization — and then fails with a minimum-deployment-target error. Raise the **iOS Deployment Target** of the app target in Xcode to 16.0.
+
+Note: React Native 0.87.0 ships `hermes-compiler` for bytecode version 98 while its prebuilt SwiftPM Hermes runtime expects 99, so any build with an embedded JS bundle crashes at startup. Install `hermes-compiler@^260318099` until a React Native release aligns the two.

package/android/build.gradle

@@ -141,6 +141,6 @@ repositories {
 }
 
 dependencies {
-    api "ly.img:camera:1.81.1"
+    api "ly.img:camera:1.82.0-rc.1"
     implementation "com.facebook.react:react-native"
 }

package/ios/IMGLYCameraModuleImplementation.swift

@@ -0,0 +1,47 @@
+import Foundation
+#if canImport(IMGLYCameraModuleObjC)
+  // Swift Package Manager builds the Objective-C++ bridge as a separate target.
+  // Under CocoaPods both languages share one module, so no import is needed.
+  import IMGLYCameraModuleObjC
+#endif
+
+/// The Swift implementation behind the Objective-C++ React Native bridge.
+///
+/// The bridge resolves this class at runtime by its stable Objective-C name
+/// (see `IMGLYCameraModuleImplementationProvider`), so no static
+/// Objective-C → Swift reference exists. This is what allows building the
+/// module with Swift Package Manager, which cannot compile mixed
+/// Swift/Objective-C++ targets (SE-0403).
+@objc(IMGLYCameraModuleDefaultImplementation)
+final class IMGLYCameraModuleDefaultImplementation: NSObject, IMGLYCameraModuleImplementation {
+  func openCamera(
+    withSettings settings: [AnyHashable: Any],
+    video: String?,
+    metadata: [AnyHashable: Any]?,
+    resolve: @escaping IMGLYCameraResolveBlock,
+    reject: @escaping IMGLYCameraRejectBlock,
+  ) {
+    guard let settings = settings as? [String: Any],
+          let cameraSettings = CameraSettings.fromDictionary(settings) else {
+      reject("E_PARSING", "Unable to parse the argument(s): ", nil)
+      return
+    }
+    let metadata = metadata as? [String: Any]
+
+    DispatchQueue.main.async {
+      IMGLYCameraModuleSwiftAdapter.shared.openCamera(
+        settings: cameraSettings,
+        video: video,
+        metadata: metadata,
+      ) { result, error in
+        if let result {
+          resolve(result.toDictionary())
+        } else if let error {
+          reject("E_RECORDING_FAILED", "The recording failed due to: ", error)
+        } else {
+          resolve(NSNull())
+        }
+      }
+    }
+  }
+}

package/ios/Model/CameraResult.swift

@@ -1,3 +1,5 @@
+import CoreGraphics
+import Foundation
 import IMGLYCamera
 
 /// The result type for a camera reaction session.

package/ios/Package.swift

@@ -0,0 +1,95 @@
+// swift-tools-version: 6.1
+// 6.1 is the parse floor for the trailing-comma syntax SwiftFormat enforces (SE-0439). The
+// toolchain floor comes from the IMGLYUI-swift dependency (tools 6.3.1) — do not lower this.
+
+// Hand-authored manifest for React Native's experimental Swift Package Manager
+// mode (React Native >= 0.87, `npx react-native spm`). CocoaPods
+// (IMGLYCameraModule.podspec) remains the supported default integration.
+//
+// React Native's SPM autolinking consumes this manifest through a symlink at
+// <app>/ios/build/generated/autolinking/libs/CameraReactNative -> this
+// directory, so the relative package references below resolve against that
+// location. This is React Native's documented contract for libraries that ship
+// their own manifest (react-native/scripts/spm/__doc__/spm-header-paths-contract.md);
+// the package and product must be named after the npm package
+// (@imgly/camera-react-native -> CameraReactNative).
+//
+// The Objective-C++ bridge and the Swift implementation are separate targets
+// because SwiftPM cannot compile mixed-language targets (SE-0403). The bridge
+// resolves the Swift implementation at runtime (IMGLYCameraModuleSupport.h),
+// so no Objective-C -> Swift compile-time dependency exists.
+
+import Foundation
+import PackageDescription
+
+// Single-source the version from package.json, like the podspec does, so
+// release automation bumps the IMG.LY dependency pin together with the
+// package version. React Native's autolinking references this manifest
+// through a symlink, so resolve it before walking up to the package root.
+let version: Version = {
+  let packageJSON = URL(fileURLWithPath: #filePath)
+    .resolvingSymlinksInPath()
+    .deletingLastPathComponent()
+    .deletingLastPathComponent()
+    .appendingPathComponent("package.json")
+  guard let data = try? Data(contentsOf: packageJSON),
+        let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+        let versionString = json["version"] as? String,
+        let version = Version(versionString) else {
+    fatalError("Unable to read the package version from \(packageJSON.path).")
+  }
+  return version
+}()
+
+let package = Package(
+  name: "CameraReactNative",
+  platforms: [
+    .iOS(.v16),
+  ],
+  products: [
+    .library(name: "CameraReactNative", targets: ["IMGLYCameraModule", "IMGLYCameraModuleObjC"]),
+  ],
+  dependencies: [
+    .package(name: "ReactNative", path: "../../../../xcframeworks"),
+    .package(name: "React-GeneratedCode", path: "../../../ios"),
+    // Pinned exactly: the module and IMGLYUI are versioned in lockstep, matching the podspec.
+    .package(url: "https://github.com/imgly/IMGLYUI-swift.git", exact: version),
+  ],
+  targets: [
+    .target(
+      name: "IMGLYCameraModuleObjC",
+      dependencies: [
+        .product(name: "ReactHeaders", package: "ReactNative"),
+        .product(name: "ReactNativeHeaders", package: "ReactNative"),
+        .product(name: "ReactNativeDependenciesHeaders", package: "ReactNative"),
+        .product(name: "ReactAppHeaders", package: "React-GeneratedCode"),
+      ],
+      path: "bridge",
+      publicHeadersPath: "include",
+      cxxSettings: [
+        // React Native's SwiftPM autolinking defines this for no target, while
+        // CocoaPods defines it for every one. Without it this module would
+        // compile its legacy bridge branch and run behind the TurboModule
+        // interop layer, so the integration path would decide the dispatch
+        // mechanism. The codegen'd spec headers the branch needs come from the
+        // ReactAppHeaders product above.
+        .define("RCT_NEW_ARCH_ENABLED", to: "1"),
+        .define("DEBUG", .when(configuration: .debug)),
+        .define("NDEBUG", .when(configuration: .release)),
+      ],
+      linkerSettings: [.linkedFramework("Foundation")],
+    ),
+    .target(
+      name: "IMGLYCameraModule",
+      dependencies: [
+        "IMGLYCameraModuleObjC",
+        .product(name: "IMGLYCamera", package: "IMGLYUI-swift"),
+      ],
+      path: ".",
+      exclude: ["bridge"],
+    ),
+  ],
+  // The module sources are written for the Swift 5 language mode.
+  swiftLanguageModes: [.v5],
+  cxxLanguageStandard: .cxx20,
+)

package/ios/{IMGLYCameraModule.mm → bridge/IMGLYCameraModule.mm}

@@ -1,5 +1,5 @@
 #import "IMGLYCameraModule.h"
-#import "IMGLYCameraModule/IMGLYCameraModule-Swift.h"
+#import "IMGLYCameraModuleSupport.h"
 
 @implementation IMGLYCameraModule
 
@@ -52,21 +52,12 @@ RCT_EXPORT_METHOD(openCamera : (nonnull NSDictionary*)settings video : (nullable
     metadata:(NSDictionary*)metadata
      resolve:(RCTPromiseResolveBlock)resolve
       reject:(RCTPromiseRejectBlock)reject {
-  CameraSettings* cameraSettings = [CameraSettings fromDictionary:settings];
-  dispatch_async(dispatch_get_main_queue(), ^{
-    [[IMGLYCameraModuleSwiftAdapter shared]
-      openCameraWithSettings:cameraSettings
-                       video:video
-                    metadata:metadata
-                  completion:^(CameraResult* _Nullable result, NSError* _Nullable error) {
-                    if (result != nil) {
-                      resolve([result toDictionary]);
-                    } else if (error != nil) {
-                      reject(@"E_RECORDING_FAILED", @"The recording failed due to: ", error);
-                    } else {
-                      resolve([NSNull null]);
-                    }
-                  }];
-  });
+  id<IMGLYCameraModuleImplementation> implementation = IMGLYCameraModuleImplementationProvider.implementation;
+  if (implementation == nil) {
+    reject(@"E_IMPLEMENTATION_MISSING",
+           @"The Swift implementation of the IMGLYCamera module was not linked into the app.", nil);
+    return;
+  }
+  [implementation openCameraWithSettings:settings video:video metadata:metadata resolve:resolve reject:reject];
 }
 @end

package/ios/bridge/IMGLYCameraModuleSupport.m

@@ -0,0 +1,23 @@
+#import "IMGLYCameraModuleSupport.h"
+
+@implementation IMGLYCameraModuleImplementationProvider
+
++ (nullable id<IMGLYCameraModuleImplementation>)implementation {
+  static id<IMGLYCameraModuleImplementation> implementation;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    // The Swift class is looked up by its stable Objective-C runtime name
+    // (`IMGLYCameraModuleImplementation.swift`) because this target must not
+    // reference Swift at compile time. React Native apps link with `-ObjC` on
+    // both the CocoaPods and the Swift Package Manager path, which keeps the
+    // class alive in Release and Archive builds despite the missing static
+    // reference.
+    Class implementationClass = NSClassFromString(@"IMGLYCameraModuleDefaultImplementation");
+    if ([implementationClass conformsToProtocol:@protocol(IMGLYCameraModuleImplementation)]) {
+      implementation = [[implementationClass alloc] init];
+    }
+  });
+  return implementation;
+}
+
+@end

package/ios/bridge/include/IMGLYCameraModuleSupport.h

@@ -0,0 +1,46 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Resolves a fulfilled result. Mirrors React Native's `RCTPromiseResolveBlock`
+/// without importing React, so the Swift implementation stays React-free.
+typedef void (^IMGLYCameraResolveBlock)(id _Nullable result);
+
+/// Rejects with an error. Mirrors React Native's `RCTPromiseRejectBlock`.
+typedef void (^IMGLYCameraRejectBlock)(NSString* code, NSString* message, NSError* _Nullable error);
+
+/// The seam between the Objective-C++ React Native bridge and the Swift
+/// implementation of the camera module.
+///
+/// The bridge resolves the implementation at runtime through
+/// `IMGLYCameraModuleImplementationProvider` instead of importing the generated
+/// `-Swift.h` header. Swift Package Manager cannot compile mixed
+/// Swift/Objective-C++ targets (SE-0403) and never emits that header, so the
+/// Objective-C target must not depend on Swift at compile time.
+@protocol IMGLYCameraModuleImplementation <NSObject>
+
+/// Opens the camera.
+/// - Parameters:
+///   - settings: The raw camera settings as received from JavaScript.
+///   - video: The source of the video to react to as received from JavaScript.
+///   - metadata: Any custom metadata as received from JavaScript.
+///   - resolve: The block to invoke with the recording result, or `NSNull` on cancellation.
+///   - reject: The block to invoke when parsing or the recording fails.
+- (void)openCameraWithSettings:(NSDictionary*)settings
+                         video:(nullable NSString*)video
+                      metadata:(nullable NSDictionary*)metadata
+                       resolve:(IMGLYCameraResolveBlock)resolve
+                        reject:(IMGLYCameraRejectBlock)reject;
+
+@end
+
+/// Resolves the Swift implementation of the camera module at runtime.
+@interface IMGLYCameraModuleImplementationProvider : NSObject
+
+/// The resolved implementation, or `nil` when the Swift part of this module
+/// was not linked into the app.
++ (nullable id<IMGLYCameraModuleImplementation>)implementation;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imgly/camera-react-native",
-  "version": "1.81.1",
+  "version": "1.82.0-rc.1",
   "description": "Camera SDK for React Native - provide a versatile video camera to your users on iOS and Android.",
   "react-native": "index.js",
   "source": "index.js",