fix: iOS production builds fail to load bundled .riv assets

android/src/main/java/com/margelo/nitro/rive/HybridRiveFileFactory.kt

@@ -9,6 +9,8 @@ import com.margelo.nitro.core.Promise
 import com.margelo.nitro.NitroModules
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import java.io.File as JavaFile
+import java.net.URI
 import java.net.URL
 
 @Keep
@@ -33,6 +35,31 @@ class HybridRiveFileFactory : HybridRiveFileFactorySpec() {
     }
   }
 
+  override fun fromFileURL(fileURL: String, loadCdn: Boolean): Promise<HybridRiveFileSpec> {
+    if (!fileURL.startsWith("file://")) {
+      throw Error("fromFileURL: URL must be a file URL: $fileURL")
+    }
+
+    return Promise.async {
+      try {
+        val uri = URI(fileURL)
+        val path = uri.path ?: throw Error("fromFileURL: Invalid URL: $fileURL")
+
+        val riveFile = withContext(Dispatchers.IO) {
+          val file = JavaFile(path)
+          val riveData = file.readBytes()
+          File(riveData)
+        }
+
+        val hybridRiveFile = HybridRiveFile()
+        hybridRiveFile.riveFile = riveFile
+        hybridRiveFile
+      } catch (e: Exception) {
+        throw Error("Failed to load Rive file: ${e.message}")
+      }
+    }
+  }
+
   @SuppressLint("DiscouragedApi")
   override fun fromResource(resource: String, loadCdn: Boolean): Promise<HybridRiveFileSpec> {
     return Promise.async {

ios/HybridRiveFileFactory.swift

@@ -38,6 +38,45 @@ class HybridRiveFileFactory: HybridRiveFileFactorySpec {
     }
   }
 
+  func fromFileURL(fileURL: String, loadCdn: Bool) throws -> Promise<(any HybridRiveFileSpec)> {
+    guard let url = URL(string:fileURL) else {
+      throw RuntimeError.error(withMessage: "fromFileURL: Invalid URL: \(fileURL)")
+    }
+
+    guard url.isFileURL else {
+      throw RuntimeError.error(withMessage: "fromFileURL: URL must be a file URL: \(fileURL)")
+    }
+
+    return Promise.async {
+      do {
+        let riveFile = try await withCheckedThrowingContinuation { continuation in
+          DispatchQueue.global(qos: .userInitiated).async {
+            do {
+              let data = try Data(contentsOf: url)
+
+              let riveFile = try RiveFile(data: data, loadCdn: loadCdn)
+              DispatchQueue.main.async {
+                continuation.resume(returning: riveFile)
+              }
+            } catch {
+              DispatchQueue.main.async {
+                continuation.resume(throwing: error)
+              }
+            }
+          }
+        }
+
+        let hybridRiveFile = HybridRiveFile()
+        hybridRiveFile.riveFile = riveFile
+        return hybridRiveFile
+      } catch let error as NSError {
+        throw RuntimeError.error(withMessage: "Failed to load Rive file: \(error.localizedDescription)")
+      } catch {
+        throw RuntimeError.error(withMessage: "Unknown error occurred while loading Rive file")
+      }
+    }
+  }
+
   func fromResource(resource: String, loadCdn: Bool) throws -> Promise<(any HybridRiveFileSpec)> {
     guard let _ = Bundle.main.path(forResource: resource, ofType: "riv") else {
       throw RuntimeError.error(withMessage: "Could not find Rive file: \(resource).riv")

src/core/RiveFile.ts

@@ -29,6 +29,19 @@ export namespace RiveFileFactory {
     return RiveFileInternal.fromURL(url, loadCdn);
   }
 
+  /**
+   * Creates a RiveFile instance from a local file path URL.
+   * @param pathURL - The local file path of the Rive graphic file
+   * @param loadCdn - Whether to load from CDN (default: true)
+   * @returns Promise that resolves to a RiveFile instance
+   */
+  export async function fromFileURL(
+    fileURL: string,
+    loadCdn: boolean = true
+  ): Promise<RiveFile> {
+    return RiveFileInternal.fromFileURL(fileURL, loadCdn);
+  }
+
   /**
    * Creates a RiveFile instance from a local resource.
    * @param resource - The name of the local resource
@@ -100,11 +113,7 @@ export namespace RiveFileFactory {
 
       // handle iOS bundled asset
       if (assetURI.match(/file:\/\//)) {
-        const match = assetURI.match(/file:\/\/(.*\/)+(.*)\.riv/);
-        if (!match) {
-          throw new Error(`Invalid iOS asset path format: ${assetURI}`);
-        }
-        return RiveFileFactory.fromResource(match[2], loadCdn);
+        return RiveFileFactory.fromFileURL(assetURI, loadCdn);
       }
 
       // handle Android bundled asset or resource name uri

src/specs/RiveFile.nitro.ts

@@ -22,6 +22,7 @@ export interface RiveFile
 export interface RiveFileFactory
   extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
   fromURL(url: string, loadCdn: boolean): Promise<RiveFile>;
+  fromFileURL(fileURL: string, loadCdn: boolean): Promise<RiveFile>;
   fromResource(resource: string, loadCdn: boolean): Promise<RiveFile>;
   fromBytes(bytes: ArrayBuffer, loadCdn: boolean): Promise<RiveFile>;
 }