react-native-cloud-storage 2.2.2 → 3.0.0

package/ios/CloudStorageCloudKit.swift

@@ -0,0 +1,159 @@
+import Foundation
+import React
+
+@objc(CloudStorageCloudKit)
+public class CloudStorageCloudKit: NSObject {
+  @objc(fileExists:withScope:withResolver:withRejecter:)
+  public func fileExists(path: String, scope: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let fileUrl = try CloudKitUtils.getFileURL(path: path, scope: scope)
+      return try FileUtils.checkFileExists(fileUrl: fileUrl)
+    }
+  }
+
+  @objc(appendToFile:withData:withScope:withResolver:withRejecter:)
+  public func appendToFile(path: String, data: String, scope: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let fileUrl = try CloudKitUtils.getFileURL(path: path, scope: scope)
+
+      var existingData = ""
+      if try FileUtils.checkFileExists(fileUrl: fileUrl) {
+        existingData = try FileUtils.readFile(fileUrl: fileUrl)
+      }
+
+      let newData = existingData + data
+      return try FileUtils.writeFile(fileUrl: fileUrl, content: newData)
+    }
+  }
+
+  @objc(createFile:withData:withScope:withOverwrite:withResolver:withRejecter:)
+  public func createFile(path: String, data: String, scope: String, overwrite: Bool, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let fileUrl = try CloudKitUtils.getFileURL(path: path, scope: scope)
+
+      if try (FileUtils.checkFileExists(fileUrl: fileUrl) && !overwrite) {
+        throw CloudStorageError.fileAlreadyExists(path: path)
+      }
+
+      return try FileUtils.writeFile(fileUrl: fileUrl, content: data)
+    }
+  }
+
+  @objc(createDirectory:withScope:withResolver:withRejecter:)
+  public func createDirectory(path: String, scope: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let fileUrl = try CloudKitUtils.getFileURL(path: path, scope: scope)
+      return try FileUtils.createDirectory(directoryUrl: fileUrl)
+    }
+  }
+
+  @objc(listFiles:withScope:withResolver:withRejecter:)
+  public func listFiles(path: String, scope: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let fileUrl = try CloudKitUtils.getFileURL(path: path, scope: scope)
+      return try FileUtils.listFiles(directoryUrl: fileUrl)
+    }
+  }
+
+  @objc(readFile:withScope:withResolver:withRejecter:)
+  public func readFile(path: String, scope: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let fileUrl = try CloudKitUtils.getFileURL(path: path, scope: scope)
+      return try FileUtils.readFile(fileUrl: fileUrl)
+    }
+  }
+
+  @objc(triggerSync:withScope:withResolver:withRejecter:)
+  public func triggerSync(path: String, scope: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let fileUrl = try CloudKitUtils.getFileURL(path: path, scope: scope)
+      return try CloudKitUtils.triggerSync(fileUrl: fileUrl)
+    }
+  }
+
+  @objc(deleteFile:withScope:withResolver:withRejecter:)
+  public func deleteFile(path: String, scope: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let fileUrl = try CloudKitUtils.getFileURL(path: path, scope: scope)
+      return try FileUtils.deleteFileOrDirectory(fileUrl: fileUrl)
+    }
+  }
+
+  @objc(deleteDirectory:withRecursive:withScope:withResolver:withRejecter:)
+  public func deleteDirectory(path: String, recursive _: Bool, scope: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let fileUrl = try CloudKitUtils.getFileURL(path: path, scope: scope)
+      return try FileUtils.deleteFileOrDirectory(fileUrl: fileUrl)
+    }
+  }
+
+  @objc(statFile:withScope:withResolver:withRejecter:)
+  public func statFile(path: String, scope: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let fileUrl = try CloudKitUtils.getFileURL(path: path, scope: scope)
+      return try FileUtils.statFile(fileUrl: fileUrl).toDictionary()
+    }
+  }
+
+  @objc(downloadFile:withLocalPath:withScope:withResolver:withRejecter:)
+  public func downloadFile(remotePath: String, localPath: String, scope: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let sourceUrl = try CloudKitUtils.getFileURL(path: remotePath, scope: scope, true)
+
+      let sourceStat = try FileUtils.statFile(fileUrl: sourceUrl)
+      if sourceStat.isDirectory {
+        throw CloudStorageError.pathIsDirectory(path: remotePath)
+      }
+
+      let destinationUrl = URL(fileURLWithPath: localPath)
+      let destinationDirectoryUrl = destinationUrl.deletingLastPathComponent()
+
+      if try !FileUtils.checkFileExists(fileUrl: destinationDirectoryUrl) {
+        throw CloudStorageError.directoryNotFound(path: destinationDirectoryUrl.path)
+      }
+
+      let destDirStat = try FileUtils.statFile(fileUrl: destinationDirectoryUrl)
+      if !destDirStat.isDirectory {
+        throw CloudStorageError.pathIsFile(path: destinationDirectoryUrl.path)
+      }
+
+      if try FileUtils.checkFileExists(fileUrl: destinationUrl) {
+        throw CloudStorageError.fileAlreadyExists(path: localPath)
+      }
+
+      return try FileUtils.copyFile(from: sourceUrl, to: destinationUrl)
+    }
+  }
+
+  @objc(uploadFile:withLocalPath:withMimeType:withScope:withOverwrite:withResolver:withRejecter:)
+  public func uploadFile(remotePath: String, localPath: String, mimeType _: String, scope: String, overwrite: Bool, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let destinationUrl = try CloudKitUtils.getFileURL(path: remotePath, scope: scope)
+      let sourceUrl = URL(fileURLWithPath: localPath)
+
+      if try !FileUtils.checkFileExists(fileUrl: sourceUrl) {
+        throw CloudStorageError.fileNotFound(path: localPath)
+      }
+
+      let destinationDirectoryUrl = destinationUrl.deletingLastPathComponent()
+      try FileUtils.createDirectory(directoryUrl: destinationDirectoryUrl)
+
+      if try FileUtils.checkFileExists(fileUrl: destinationUrl) {
+        if overwrite {
+          try FileUtils.deleteFileOrDirectory(fileUrl: destinationUrl)
+        } else {
+          throw CloudStorageError.fileAlreadyExists(path: remotePath)
+        }
+      }
+
+      return try FileUtils.copyFile(from: sourceUrl, to: destinationUrl)
+    }
+  }
+
+  @objc(isCloudAvailable:withRejecter:)
+  public func isCloudAvailable(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      CloudKitUtils.isCloudKitAvailable()
+    }
+  }
+}

package/ios/CloudStorageLocalFileSystem.swift

@@ -0,0 +1,216 @@
+import Foundation
+import MobileCoreServices
+import React
+
+// MARK: - CloudStorageLocalFileSystem
+
+@objc(CloudStorageLocalFileSystem)
+public class CloudStorageLocalFileSystem: NSObject {
+  @objc
+  public func constantsToExport() -> [AnyHashable: Any]! {
+    [
+      "temporaryDirectory": FileUtils.temporaryDirectory.path,
+    ]
+  }
+
+  @objc(createFile:withData:withResolver:withRejecter:)
+  public func createFile(path: String, data: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let fileUrl = URL(fileURLWithPath: path)
+      let directoryUrl = fileUrl.deletingLastPathComponent()
+
+      var isDirectory: ObjCBool = false
+      if !FileManager.default.fileExists(atPath: directoryUrl.path, isDirectory: &isDirectory) {
+        throw CloudStorageError.directoryNotFound(path: directoryUrl.path)
+      }
+
+      if !isDirectory.boolValue {
+        throw CloudStorageError.pathIsFile(path: directoryUrl.path)
+      }
+
+      try FileUtils.writeFile(fileUrl: fileUrl, content: data)
+      return fileUrl.path
+    }
+  }
+
+  @objc(readFile:withResolver:withRejecter:)
+  public func readFile(path: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let fileUrl = URL(fileURLWithPath: path)
+      return try FileUtils.readFile(fileUrl: fileUrl)
+    }
+  }
+
+  @objc(downloadFile:withLocalPath:withOptions:withResolver:withRejecter:)
+  public func downloadFile(remoteUri: String, localPath: String, options: [String: Any]?, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    guard let remoteUrl = URL(string: remoteUri) else {
+      let error = CloudStorageError.invalidUrl(url: remoteUri)
+      reject(error.code, error.message, nil)
+      return
+    }
+
+    let sanitizedPath = sanitizePath(localPath)
+    let localUrl = URL(fileURLWithPath: sanitizedPath)
+
+    let configuration = URLSessionConfiguration.default
+    if let headers = options?["headers"] as? [String: String] {
+      configuration.httpAdditionalHeaders = headers
+    }
+    let session = URLSession(configuration: configuration)
+
+    let downloadTask = session.downloadTask(with: remoteUrl) { tempLocalUrl, _, error in
+      if let error {
+        let nsError = error as NSError
+        let cloudError = CloudStorageError.networkError(message: "Download error for path \(remoteUri): \(nsError.localizedDescription)")
+        reject(cloudError.code, cloudError.message, nsError)
+        return
+      }
+
+      guard let tempLocalUrl else {
+        let cloudError = CloudStorageError.unknown(message: "Download failed: temporary file location is missing.")
+        reject(cloudError.code, cloudError.message, nil)
+        return
+      }
+
+      do {
+        let directory = localUrl.deletingLastPathComponent()
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true, attributes: nil)
+
+        if FileManager.default.fileExists(atPath: localUrl.path) {
+          try FileManager.default.removeItem(at: localUrl)
+        }
+
+        try FileManager.default.moveItem(at: tempLocalUrl, to: localUrl)
+        resolve(nil)
+      } catch {
+        let nsError = error as NSError
+        let cloudError = CloudStorageError.writeError(path: localUrl.path)
+        reject(cloudError.code, cloudError.message, nsError)
+      }
+    }
+
+    downloadTask.resume()
+  }
+
+  @objc(uploadFile:withRemoteUri:withOptions:withResolver:withRejecter:)
+  public func uploadFile(localPath: String, remoteUri: String, options: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    guard let remoteUrl = URL(string: remoteUri) else {
+      let error = CloudStorageError.invalidUrl(url: remoteUri)
+      reject(error.code, error.message, nil)
+      return
+    }
+
+    let sanitizedPath = sanitizePath(localPath)
+    let localUrl = URL(fileURLWithPath: sanitizedPath)
+
+    guard let uploadTypeString = options["uploadType"] as? String,
+          let uploadType = UploadType(rawValue: uploadTypeString) else {
+      let error = CloudStorageError.unknown(message: "uploadType is required and must be either 'multipart' or 'binary'")
+      reject(error.code, error.message, nil)
+      return
+    }
+
+    var request = URLRequest(url: remoteUrl)
+    request.httpMethod = (options["method"] as? String)?.uppercased() ?? "POST"
+
+    if let headers = options["headers"] as? [String: String] {
+      for (key, value) in headers {
+        request.setValue(value, forHTTPHeaderField: key)
+      }
+    }
+
+    do {
+      let fileData = try Data(contentsOf: localUrl)
+
+      switch uploadType {
+      case .binary:
+        request.httpBody = fileData
+        if request.value(forHTTPHeaderField: "Content-Type") == nil {
+          request.setValue("application/octet-stream", forHTTPHeaderField: "Content-Type")
+        }
+      case .multipart:
+        guard let fieldName = options["fieldName"] as? String else {
+          let error = CloudStorageError.unknown(message: "fieldName is required for multipart uploads")
+          reject(error.code, error.message, nil)
+          return
+        }
+
+        let boundary = "Boundary-\(UUID().uuidString)"
+        request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
+
+        var body = Data()
+        let lineBreak = "\r\n"
+
+        if let parameters = options["parameters"] as? [String: String] {
+          for (key, value) in parameters {
+            body.append("--\(boundary)\(lineBreak)")
+            body.append("Content-Disposition: form-data; name=\"\(key)\"\(lineBreak)\(lineBreak)")
+            body.append("\(value)\(lineBreak)")
+          }
+        }
+
+        body.append("--\(boundary)\(lineBreak)")
+        body.append("Content-Disposition: form-data; name=\"\(fieldName)\"; filename=\"\(localUrl.lastPathComponent)\"\(lineBreak)")
+        if let mimeType = getMimeType(for: localUrl) {
+          body.append("Content-Type: \(mimeType)\(lineBreak)\(lineBreak)")
+        } else {
+          body.append("Content-Type: application/octet-stream\(lineBreak)\(lineBreak)")
+        }
+        body.append(fileData)
+        body.append(lineBreak)
+        body.append("--\(boundary)--\(lineBreak)")
+
+        request.httpBody = body
+      }
+
+      let task = URLSession.shared.dataTask(with: request) { _, response, error in
+        if let error {
+          let nsError = error as NSError
+          let cloudError = CloudStorageError.networkError(message: "Upload error for path \(sanitizedPath): \(nsError.localizedDescription)")
+          reject(cloudError.code, cloudError.message, nsError)
+          return
+        }
+
+        guard let httpResponse = response as? HTTPURLResponse, (200 ... 299).contains(httpResponse.statusCode) else {
+          let httpResponse = response as? HTTPURLResponse
+          let message = "Upload failed for path \(sanitizedPath) with status code: \(httpResponse?.statusCode ?? -1)"
+          let cloudError = CloudStorageError.networkError(message: message)
+          reject(cloudError.code, cloudError.message, nil)
+          return
+        }
+
+        resolve(nil)
+      }
+      task.resume()
+    } catch {
+      let nsError = error as NSError
+      let cloudError = CloudStorageError.readError(path: sanitizedPath)
+      reject(cloudError.code, cloudError.message, nsError)
+    }
+  }
+
+  private func sanitizePath(_ path: String) -> String {
+    if path.hasPrefix("file://") {
+      return String(path.dropFirst("file://".count))
+    }
+    return path
+  }
+
+  private func getMimeType(for url: URL) -> String? {
+    let pathExtension = url.pathExtension
+    if let uti = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, pathExtension as CFString, nil)?.takeRetainedValue() {
+      if let mimetype = UTTypeCopyPreferredTagWithClass(uti, kUTTagClassMIMEType)?.takeRetainedValue() {
+        return mimetype as String
+      }
+    }
+    return nil
+  }
+}
+
+extension Data {
+  mutating func append(_ string: String) {
+    if let data = string.data(using: .utf8) {
+      append(data)
+    }
+  }
+}

package/ios/RCTCloudStorageCloudKit.mm

@@ -0,0 +1,209 @@
+#import <Foundation/Foundation.h>
+
+#import <CloudStorageSpec/CloudStorageSpec.h>
+
+#if __has_include("react_native_cloud_storage-Swift.h")
+#import "react_native_cloud_storage-Swift.h"
+#elif __has_include(<react_native_cloud_storage/react_native_cloud_storage-Swift.h>)
+#import <react_native_cloud_storage/react_native_cloud_storage-Swift.h>
+#else
+#error "Unable to locate Swift compatibility header for react-native-cloud-storage."
+#endif
+
+@interface RCTCloudStorageCloudKit : NativeCloudStorageCloudKitIOSSpecBase <NativeCloudStorageCloudKitIOSSpec>
+@end
+
+@implementation RCTCloudStorageCloudKit {
+  CloudStorageCloudKit *_cloudStorageCloudKit;
+  id<NSObject> _ubiquityIdentityObserver;
+}
+
++ (NSString *)moduleName
+{
+  return @"CloudStorageCloudKit";
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _cloudStorageCloudKit = [CloudStorageCloudKit new];
+
+    __weak __typeof__(self) weakSelf = self;
+    _ubiquityIdentityObserver = [[NSNotificationCenter defaultCenter]
+        addObserverForName:NSUbiquityIdentityDidChangeNotification
+                    object:nil
+                     queue:nil
+                usingBlock:^(__unused NSNotification *notification) {
+                  __strong __typeof__(weakSelf) strongSelf = weakSelf;
+                  [strongSelf emitCloudAvailabilityChanged];
+                }];
+  }
+
+  return self;
+}
+
+- (void)dealloc
+{
+  if (_ubiquityIdentityObserver != nil) {
+    [[NSNotificationCenter defaultCenter] removeObserver:_ubiquityIdentityObserver];
+    _ubiquityIdentityObserver = nil;
+  }
+}
+
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper
+{
+  [super setEventEmitterCallback:eventEmitterCallbackWrapper];
+  [self emitCloudAvailabilityChanged];
+}
+
+- (void)emitCloudAvailabilityChanged
+{
+  BOOL isCloudAvailable = [NSFileManager defaultManager].ubiquityIdentityToken != nil;
+  [self emitOnCloudAvailabilityChanged:@{ @"available" : @(isCloudAvailable) }];
+}
+
+- (void)fileExists:(NSString *)path
+             scope:(NSString *)scope
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageCloudKit fileExists:path withScope:scope withResolver:resolve withRejecter:reject];
+}
+
+- (void)appendToFile:(NSString *)path
+                data:(NSString *)data
+               scope:(NSString *)scope
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageCloudKit appendToFile:path withData:data withScope:scope withResolver:resolve withRejecter:reject];
+}
+
+- (void)createFile:(NSString *)path
+              data:(NSString *)data
+             scope:(NSString *)scope
+         overwrite:(BOOL)overwrite
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageCloudKit
+      createFile:path
+         withData:data
+        withScope:scope
+    withOverwrite:overwrite
+      withResolver:resolve
+      withRejecter:reject];
+}
+
+- (void)createDirectory:(NSString *)path
+                  scope:(NSString *)scope
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageCloudKit createDirectory:path withScope:scope withResolver:resolve withRejecter:reject];
+}
+
+- (void)listFiles:(NSString *)path
+            scope:(NSString *)scope
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageCloudKit listFiles:path withScope:scope withResolver:resolve withRejecter:reject];
+}
+
+- (void)readFile:(NSString *)path
+           scope:(NSString *)scope
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageCloudKit readFile:path withScope:scope withResolver:resolve withRejecter:reject];
+}
+
+- (void)triggerSync:(NSString *)path
+              scope:(NSString *)scope
+            resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageCloudKit triggerSync:path withScope:scope withResolver:resolve withRejecter:reject];
+}
+
+- (void)deleteFile:(NSString *)path
+             scope:(NSString *)scope
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageCloudKit deleteFile:path withScope:scope withResolver:resolve withRejecter:reject];
+}
+
+- (void)deleteDirectory:(NSString *)path
+              recursive:(BOOL)recursive
+                  scope:(NSString *)scope
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageCloudKit
+      deleteDirectory:path
+         withRecursive:recursive
+             withScope:scope
+          withResolver:resolve
+          withRejecter:reject];
+}
+
+- (void)statFile:(NSString *)path
+           scope:(NSString *)scope
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageCloudKit statFile:path withScope:scope withResolver:resolve withRejecter:reject];
+}
+
+- (void)downloadFile:(NSString *)remotePath
+           localPath:(NSString *)localPath
+               scope:(NSString *)scope
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageCloudKit
+      downloadFile:remotePath
+     withLocalPath:localPath
+         withScope:scope
+      withResolver:resolve
+      withRejecter:reject];
+}
+
+- (void)uploadFile:(NSString *)remotePath
+         localPath:(NSString *)localPath
+          mimeType:(NSString *)mimeType
+             scope:(NSString *)scope
+         overwrite:(BOOL)overwrite
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageCloudKit
+      uploadFile:remotePath
+       withLocalPath:localPath
+       withMimeType:mimeType
+         withScope:scope
+     withOverwrite:overwrite
+      withResolver:resolve
+      withRejecter:reject];
+}
+
+- (void)isCloudAvailable:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageCloudKit isCloudAvailable:resolve withRejecter:reject];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeCloudStorageCloudKitIOSSpecJSI>(params);
+}
+
+@end