@rive-app/react-native 0.1.1-beta.0

package/ios/DataSourceResolver.swift

@@ -0,0 +1,55 @@
+import Foundation
+
+struct DataSourceResolver {
+  static func resolve(from asset: ResolvedReferencedAsset) throws -> DataSource? {
+    if let sourceUrl = asset.sourceUrl {
+      return try resolveFromUrl(sourceUrl)
+    }
+
+    if let sourceAssetId = asset.sourceAssetId {
+      return try resolveFromAssetId(sourceAssetId)
+    }
+
+    if let sourceAsset = asset.sourceAsset {
+      return resolveFromSourceAsset(sourceAsset)
+    }
+
+    return nil
+  }
+
+  private static func resolveFromUrl(_ urlString: String) throws -> DataSource {
+    guard let url = URL(string: urlString) else {
+      throw DataLoaderError.invalidURL(urlString)
+    }
+
+    if url.isFileURL {
+      return .file(url: url)
+    }
+
+    if url.scheme == "http" || url.scheme == "https" {
+      return .http(url: url)
+    }
+
+    throw DataLoaderError.invalidURL(urlString)
+  }
+
+  private static func resolveFromAssetId(_ assetId: String) throws -> DataSource {
+    guard let url = URL(string: assetId) else {
+      throw DataLoaderError.invalidURL(assetId)
+    }
+
+    if url.isFileURL {
+      return .file(url: url)
+    }
+
+    if url.scheme == "http" || url.scheme == "https" {
+      return .http(url: url)
+    }
+
+    throw DataLoaderError.invalidURL(assetId)
+  }
+
+  private static func resolveFromSourceAsset(_ sourceAsset: String) -> DataSource {
+    return .bundle(nameWithExtension: sourceAsset)
+  }
+}

package/ios/EventPropertiesOutputExtensions.swift

@@ -0,0 +1,15 @@
+import Foundation
+
+extension EventPropertiesOutput {
+  static func boolean(_ value: Bool) -> EventPropertiesOutput {
+    return .first(value)
+  }
+
+  static func string(_ value: String) -> EventPropertiesOutput {
+    return .second(value)
+  }
+
+  static func number(_ value: Double) -> EventPropertiesOutput {
+    return .third(value)
+  }
+}

package/ios/FileDataLoader.swift

@@ -0,0 +1,24 @@
+import Foundation
+
+final class FileDataLoader: DataLoader {
+  func load(from source: DataSource) async throws -> Data {
+    guard case .file(let url) = source else {
+      throw DataLoaderError.invalidSource
+    }
+    return try loadData(from: url)
+  }
+
+  func loadData(from url: URL) throws -> Data {
+    guard FileManager.default.fileExists(atPath: url.path) else {
+      throw DataLoaderError.fileNotFound(path: url.path)
+    }
+    return try Data(contentsOf: url)
+  }
+
+  func loadData(from path: String) throws -> Data {
+    guard let url = URL(string: path), url.isFileURL else {
+      throw DataLoaderError.invalidURL(path)
+    }
+    return try loadData(from: url)
+  }
+}

package/ios/HTTPDataLoader.swift

@@ -0,0 +1,31 @@
+import Foundation
+
+final class HTTPDataLoader: DataLoader {
+  static let shared = HTTPDataLoader()
+
+  func load(from source: DataSource) async throws -> Data {
+    guard case .http(let url) = source else {
+      throw DataLoaderError.invalidSource
+    }
+    return try await downloadData(from: url)
+  }
+
+  func downloadData(from url: URL) async throws -> Data {
+    let (data, response) = try await URLSession.shared.data(from: url)
+
+    if let httpResponse = response as? HTTPURLResponse,
+      !(200...299).contains(httpResponse.statusCode)
+    {
+      throw DataLoaderError.httpError(statusCode: httpResponse.statusCode, url: url)
+    }
+
+    return data
+  }
+
+  func downloadData(from urlString: String) async throws -> Data {
+    guard let url = URL(string: urlString) else {
+      throw DataLoaderError.invalidURL(urlString)
+    }
+    return try await downloadData(from: url)
+  }
+}

package/ios/HybridRiveFile.swift

@@ -0,0 +1,113 @@
+import RiveRuntime
+
+typealias ReferencedAssetCache = [String: RiveFileAsset]
+
+class HybridRiveFile: HybridRiveFileSpec, RiveViewSource {
+  var riveFile: RiveFile?
+  var referencedAssetCache: ReferencedAssetCache?
+  var assetLoader: ReferencedAssetLoader?
+  var cachedFactory: RiveFactory?
+  private var weakViews: [Weak<RiveReactNativeView>] = []
+
+  public func setRiveFile(_ riveFile: RiveFile) {
+    self.riveFile = riveFile
+  }
+
+  func registerView(_ view: RiveReactNativeView) {
+    weakViews.append(Weak(view))
+  }
+
+  func unregisterView(_ view: RiveReactNativeView) {
+    weakViews.removeAll { $0.value === view }
+  }
+
+  private func refreshAfterAssetChange() {
+    weakViews = weakViews.filter { $0.value != nil }
+
+    for weakView in weakViews {
+      guard let view = weakView.value else { continue }
+      view.refreshAfterAssetChange()
+    }
+  }
+  
+  var viewModelCount: Double? {
+    guard let count = riveFile?.viewModelCount else { return nil }
+    return Double(count)
+  }
+  
+  func viewModelByIndex(index: Double) throws -> (any HybridViewModelSpec)? {
+    guard let vm = riveFile?.viewModel(at: UInt(index)) else { return nil }
+    return HybridViewModel(viewModel: vm)
+  }
+  
+  func viewModelByName(name: String) throws -> (any HybridViewModelSpec)? {
+    guard let vm = riveFile?.viewModelNamed(name) else { return nil }
+    return HybridViewModel(viewModel: vm)
+  }
+  
+  func defaultArtboardViewModel(artboardBy: ArtboardBy?) throws -> (any HybridViewModelSpec)? {
+    let artboard: RiveArtboard?
+    
+    if let artboardBy = artboardBy {
+      switch artboardBy.type {
+      case .index:
+        guard let index = artboardBy.index else { return nil }
+        artboard = try? riveFile?.artboard(from: Int(index))
+      case .name:
+        guard let name = artboardBy.name else { return nil }
+        artboard = try? riveFile?.artboard(fromName: name)
+      default:
+        artboard = nil
+      }
+    } else {
+      artboard = try? riveFile?.artboard()
+    }
+    
+    guard let artboard = artboard,
+          let vm = riveFile?.defaultViewModel(for: artboard) else { return nil }
+    return HybridViewModel(viewModel: vm)
+  }
+  
+  func updateReferencedAssets(referencedAssets: ReferencedAssetsType) {
+    guard let assetsData = referencedAssets.data,
+          let cache = referencedAssetCache,
+          let loader = assetLoader,
+          let _ = riveFile else {
+      return
+    }
+
+    let dispatchGroup = DispatchGroup()
+    var hasChanged = false
+
+    for (key, assetData) in assetsData {
+      guard let asset = cache[key] else { continue }
+      if let riveFactory = cachedFactory {
+        dispatchGroup.enter()
+        loader.loadAsset(source: assetData, asset: asset, factory: riveFactory) {
+          dispatchGroup.leave()
+        }
+      } else {
+        RCTLogError("[RiveFile] no factory available for update")
+      }
+      hasChanged = true
+    }
+
+    if hasChanged {
+      dispatchGroup.notify(queue: .main) { [weak self] in
+        self?.refreshAfterAssetChange()
+      }
+    }
+  }
+  
+  func dispose() {
+    weakViews.removeAll()
+    referencedAssetCache = nil
+    assetLoader = nil
+    cachedFactory = nil
+    riveFile = nil
+  }
+
+  deinit {
+    dispose()
+  }
+}

package/ios/HybridRiveFileFactory.swift

@@ -0,0 +1,163 @@
+import NitroModules
+import RiveRuntime
+
+final class HybridRiveFileFactory: HybridRiveFileFactorySpec, @unchecked Sendable {
+  let assetLoader = ReferencedAssetLoader()
+
+  /// Asynchronously creates a `HybridRiveFileSpec` by performing the following steps:
+  /// 1. Executes `check()` to validate or fetch initial data.
+  /// 2. Processes the result with `prepare()`.
+  /// 3. If a custom asset loader is available, loads the file using `fileWithCustomAssetLoader(prepared, assetLoader)`.
+  ///    Otherwise, loads the file using `file(prepared)`.
+  /// 4. Handles referenced assets and caches as needed.
+  /// - Parameters:
+  ///   - check: Closure to validate or fetch initial data.
+  ///   - prepare: Closure to process the checked result.
+  ///   - fileWithCustomAssetLoader: Closure to load the file with a custom asset loader.
+  ///   - file: Closure to load the file without a custom asset loader.
+  ///   - referencedAssets: Optional referenced assets.
+  /// - Returns: A promise resolving to a `HybridRiveFileSpec`.
+  /// - Throws: Runtime errors if any step fails.
+  func genericFrom<CheckResult, Prepared>(
+    check: @escaping () throws -> CheckResult,
+    prepare: @escaping (CheckResult) async throws -> Prepared,
+    fileWithCustomAssetLoader: @escaping (Prepared, @escaping LoadAsset) throws -> RiveFile,
+    file: @escaping (Prepared) throws -> RiveFile,
+    referencedAssets: ReferencedAssetsType?
+  ) throws -> Promise<(any HybridRiveFileSpec)> {
+    return Promise.async {
+      do {
+        let checked = try check()
+        let prepared = try await prepare(checked)
+
+        let result = try await withCheckedThrowingContinuation { continuation in
+          DispatchQueue.global(qos: .userInitiated).async {
+            do {
+
+              let referencedAssetCache = SendableRef(ReferencedAssetCache())
+              let factoryCache: SendableRef<RiveFactory?> = .init(nil)
+              let fileRef: SendableRef<RiveFile?> = .init(nil)
+              let customLoader = self.assetLoader.createCustomLoader(
+                referencedAssets: referencedAssets, cache: referencedAssetCache,
+                factory: factoryCache,
+                fileRef: fileRef
+              )
+
+              let riveFile =
+                if let customLoader = customLoader {
+                  try fileWithCustomAssetLoader(prepared, customLoader)
+                } else {
+                  try file(prepared)
+                }
+              fileRef.value = riveFile
+
+              let result = (
+                file: riveFile, cache: referencedAssetCache.value, factory: factoryCache.value,
+                loader: customLoader != nil ? self.assetLoader : nil
+              )
+              DispatchQueue.main.async {
+                continuation.resume(returning: result)
+              }
+            } catch {
+              DispatchQueue.main.async {
+                continuation.resume(throwing: error)
+              }
+            }
+          }
+        }
+
+        let hybridRiveFile = HybridRiveFile()
+        hybridRiveFile.riveFile = result.file
+        hybridRiveFile.referencedAssetCache = result.cache
+        if let factory = result.factory {
+          hybridRiveFile.cachedFactory = factory
+        }
+        hybridRiveFile.assetLoader = result.loader
+        return hybridRiveFile
+      } catch let error as NSError {
+        throw RuntimeError.error(
+          withMessage: "Failed to download Rive file: \(error.localizedDescription)")
+      } catch {
+        throw RuntimeError.error(withMessage: "Unknown error occurred while downloading Rive file")
+      }
+    }
+  }
+
+  // MARK: Public Methods
+  func fromURL(url: String, loadCdn: Bool, referencedAssets: ReferencedAssetsType?) throws
+    -> Promise<(any HybridRiveFileSpec)> {
+    return try genericFrom(
+      check: {
+        guard let url = URL(string: url) else {
+          throw RuntimeError.error(withMessage: "Invalid URL: \(url)")
+        }
+        return url
+      },
+      prepare: { url in try await HTTPDataLoader.shared.downloadData(from: url) },
+      fileWithCustomAssetLoader: { (data, loader) in
+        try RiveFile(data: data, loadCdn: loadCdn, customAssetLoader: loader)
+      },
+      file: { (data) in try RiveFile(data: data, loadCdn: loadCdn) },
+      referencedAssets: referencedAssets
+    )
+  }
+
+  func fromFileURL(fileURL: String, loadCdn: Bool, referencedAssets: ReferencedAssetsType?) throws
+    -> Promise<(any HybridRiveFileSpec)> {
+    return try genericFrom(
+      check: {
+        guard let url = URL(string: fileURL) else {
+          throw RuntimeError.error(withMessage: "Invalid URL: \(fileURL)")
+        }
+        guard url.isFileURL else {
+          throw RuntimeError.error(withMessage: "fromFileURL: URL must be a file URL: \(fileURL)")
+        }
+        return url
+      },
+      prepare: { url in try FileDataLoader().loadData(from: url) },
+      fileWithCustomAssetLoader: { (data, loader) in
+        try RiveFile(data: data, loadCdn: loadCdn, customAssetLoader: loader)
+      },
+      file: { (data) in try RiveFile(data: data, loadCdn: loadCdn) },
+      referencedAssets: referencedAssets
+    )
+  }
+
+  func fromResource(resource: String, loadCdn: Bool, referencedAssets: ReferencedAssetsType?) throws
+    -> Promise<(any HybridRiveFileSpec)> {
+    return try genericFrom(
+      check: {
+        guard Bundle.main.path(forResource: resource, ofType: "riv") != nil else {
+          throw RuntimeError.error(withMessage: "Could not find Rive file: \(resource).riv")
+        }
+        return resource
+      },
+      prepare: { $0 },
+      fileWithCustomAssetLoader: { (resource, loader) in
+        try RiveFile(resource: resource, loadCdn: loadCdn, customAssetLoader: loader)
+      },
+      file: { (resource) in try RiveFile(resource: resource, loadCdn: loadCdn) },
+      referencedAssets: referencedAssets
+    )
+  }
+
+  func fromResource(resource: String, loadCdn: Bool) throws -> Promise<(any HybridRiveFileSpec)> {
+    return try fromResource(resource: resource, loadCdn: loadCdn, referencedAssets: nil)
+  }
+
+  func fromBytes(bytes: ArrayBufferHolder, loadCdn: Bool, referencedAssets: ReferencedAssetsType?)
+    throws -> Promise<
+      (any HybridRiveFileSpec)
+    > {
+    let data = bytes.toData(copyIfNeeded: false)
+    return try genericFrom(
+      check: { data },
+      prepare: { $0 },
+      fileWithCustomAssetLoader: { (data, loader) in
+        try RiveFile(data: data, loadCdn: loadCdn, customAssetLoader: loader)
+      },
+      file: { (data) in try RiveFile(data: data, loadCdn: loadCdn) },
+      referencedAssets: referencedAssets
+    )
+  }
+}

package/ios/HybridRiveImage.swift

@@ -0,0 +1,17 @@
+import NitroModules
+import RiveRuntime
+
+class HybridRiveImage: HybridRiveImageSpec {
+  let renderImage: RiveRenderImage
+  private let dataSize: Int
+
+  init(renderImage: RiveRenderImage, dataSize: Int) {
+    self.renderImage = renderImage
+    self.dataSize = dataSize
+    super.init()
+  }
+
+  var byteSize: Double {
+    Double(dataSize)
+  }
+}

package/ios/HybridRiveImageFactory.swift

@@ -0,0 +1,26 @@
+import NitroModules
+import RiveRuntime
+
+final class HybridRiveImageFactory: HybridRiveImageFactorySpec {
+  private func loadFromDataSource(_ source: DataSource) -> Promise<(any HybridRiveImageSpec)> {
+    return Promise.async {
+      let data = try await source.createLoader().load(from: source)
+      guard let renderImage = RiveRenderImage(data: data) else {
+        throw RuntimeError.error(withMessage: "Failed to decode image")
+      }
+      return HybridRiveImage(renderImage: renderImage, dataSize: data.count)
+    }
+  }
+
+  func loadFromURLAsync(url: String) throws -> Promise<(any HybridRiveImageSpec)> {
+    return loadFromDataSource(try .fromURL(string: url))
+  }
+
+  func loadFromResourceAsync(resource: String) throws -> Promise<(any HybridRiveImageSpec)> {
+    return loadFromDataSource(.bundle(nameWithExtension: resource))
+  }
+
+  func loadFromBytesAsync(bytes: ArrayBufferHolder) throws -> Promise<(any HybridRiveImageSpec)> {
+    return loadFromDataSource(.bytes(from: bytes))
+  }
+}