fix: eagerly dispose RiveView and break referenced asset retain cycle

RiveView now calls dispose() on the native HybridObject when the React
component unmounts, freeing the RiveView, ViewModel, and C++ scene graph
immediately instead of waiting for Hermes GC.

Also removes the withExtendedLifetime(fileRef) retain cycle in
ReferencedAssetLoader that kept RiveFile alive permanently through the
LoadAsset closure stored on the file itself.

Author: mfazekas

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

@@ -51,6 +51,12 @@ class HybridRiveView(val context: ThemedReactContext) : HybridRiveViewSpec() {
     private const val TAG = "HybridRiveView"
   }
 
+  //region Lifecycle
+  override fun dispose() {
+    view.dispose()
+  }
+  //endregion
+
   //region State
   override val view: RiveReactNativeView = RiveReactNativeView(context)
   private var needsReload = false

ios/HybridRiveFileFactory.swift

@@ -36,11 +36,9 @@ final class HybridRiveFileFactory: HybridRiveFileFactorySpec, @unchecked Sendabl
 
               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
+                factory: factoryCache
               )
 
               let riveFile =
@@ -49,7 +47,7 @@ final class HybridRiveFileFactory: HybridRiveFileFactorySpec, @unchecked Sendabl
                 } else {
                   try file(prepared)
                 }
-              fileRef.value = riveFile
+              self.assetLoader.setFileRef(riveFile)
 
               let result = (
                 file: riveFile, cache: referencedAssetCache.value, factory: factoryCache.value,

ios/HybridRiveView.swift

@@ -197,6 +197,13 @@ class HybridRiveView: HybridRiveViewSpec {
     }
   }
 
+  func dispose() {
+    let riveView = view as? RiveReactNativeView
+    DispatchQueue.main.async {
+      riveView?.cleanup()
+    }
+  }
+
   // MARK: Internal State
   private var needsReload = false
   private var dataBindingChanged = false

ios/ReferencedAssetLoader.swift

@@ -11,6 +11,27 @@ func createAssetFileError(_ assetName: String) -> NitroRiveError {
 }
 
 final class ReferencedAssetLoader {
+  // Keeps the RiveFile alive while asset loads are in flight, without creating a retain cycle
+  // through the LoadAsset closure stored on the file itself.
+  private var activeLoadCount = 0
+  private var activeFileRef: RiveFile?
+
+  func setFileRef(_ file: RiveFile) {
+    activeFileRef = file
+  }
+
+  private func retainFile() {
+    activeLoadCount += 1
+  }
+
+  private func releaseFile() {
+    activeLoadCount -= 1
+    if activeLoadCount <= 0 {
+      activeLoadCount = 0
+      activeFileRef = nil
+    }
+  }
+
   private func handleRiveError(error: Error) {
     RCTLogError("\(error)")
   }
@@ -115,16 +136,15 @@ final class ReferencedAssetLoader {
 
   func createCustomLoader(
     referencedAssets: ReferencedAssetsType?, cache: SendableRef<ReferencedAssetCache>,
-    factory factoryOut: SendableRef<RiveFactory?>,
-    fileRef: SendableRef<RiveFile?>
+    factory factoryOut: SendableRef<RiveFactory?>
   )
     -> LoadAsset?
   {
     guard let referencedAssets = referencedAssets, let referencedAssets = referencedAssets.data
     else {
       return nil
     }
-    return { (asset: RiveFileAsset, _: Data, factory: RiveFactory) -> Bool in
+    return { [weak self] (asset: RiveFileAsset, _: Data, factory: RiveFactory) -> Bool in
       let assetByUniqueName = referencedAssets[asset.uniqueName()]
       guard let assetData = assetByUniqueName ?? referencedAssets[asset.name()] else {
         return false
@@ -133,10 +153,11 @@ final class ReferencedAssetLoader {
       cache.value[asset.uniqueName()] = asset
       factoryOut.value = factory
 
-      self.loadAssetInternal(
+      self?.retainFile()
+      self?.loadAssetInternal(
         source: assetData, asset: asset, factory: factory,
-        completion: {
-          withExtendedLifetime(fileRef) {}
+        completion: { [weak self] in
+          self?.releaseFile()
         })
 
       return true

ios/RiveReactNativeView.swift

@@ -242,7 +242,7 @@ class RiveReactNativeView: UIView, RiveStateMachineDelegate {
     }
   }
 
-  private func cleanup() {
+  func cleanup() {
     riveView?.removeFromSuperview()
     riveView?.stateMachineDelegate = nil
     riveView = nil

src/core/RiveView.tsx

@@ -1,6 +1,8 @@
-import type { ComponentProps } from 'react';
+import { useEffect, useRef, type ComponentProps } from 'react';
 import { NitroRiveView } from './NitroRiveViewComponent';
 import { RiveErrorType, type RiveError } from './Errors';
+import { callDispose } from './callDispose';
+import type { RiveViewRef } from '../index';
 
 export interface RiveViewProps
   extends Omit<ComponentProps<typeof NitroRiveView>, 'onError'> {
@@ -10,39 +12,32 @@ export interface RiveViewProps
 const defaultOnError = (error: RiveError) =>
   console.error(`[${RiveErrorType[error.type]}] ${error.message}`);
 
-/**
- * RiveView is a React Native component that renders Rive graphics.
- * It provides a seamless way to display and control Rive graphics in your app.
- *
- * @example
- * ```tsx
- * <RiveView
- *   file={riveFile}
- *   artboardName="New Artboard"
- *   stateMachineName="State Machine 1"
- *   autoPlay={true}
- *   fit={Fit.Contain}
- *   style={styles.riveContainer}
- * />
- * ```
- *
- * @property {RiveFile} file - The Rive file to be displayed
- * @property {string} [artboardName] - Name of the artboard to display from the Rive file
- * @property {string} [stateMachineName] - Name of the state machine to play
- * @property {ViewModelInstance | DataBindMode | DataBindByName} [dataBind] - Data binding configuration for the state machine, defaults to DataBindMode.Auto
- * @property {boolean} [autoPlay=true] - Whether to automatically start playing the state machine
- * @property {Alignment} [alignment] - How the Rive graphic should be aligned within its container
- * @property {Fit} [fit] - How the Rive graphic should fit within its container
- * @property {Object} [style] - React Native style object for container customization
- * @property {(error: RiveError) => void} [onError] - Callback function that is called when an error occurs
- *
- * The component also exposes methods for controlling playback:
- * - play(): Starts playing the Rive graphic
- * - pause(): Pauses the Rive graphic
- */
 export function RiveView(props: RiveViewProps) {
-  const { onError, ...rest } = props;
+  const { onError, hybridRef: userHybridRef, ...rest } = props;
   const wrappedOnError = onError ?? defaultOnError;
+  const viewRef = useRef<RiveViewRef | null>(null);
 
-  return <NitroRiveView {...rest} onError={{ f: wrappedOnError }} />;
+  useEffect(() => {
+    return () => {
+      if (viewRef.current) {
+        callDispose(viewRef.current);
+        viewRef.current = null;
+      }
+    };
+  }, []);
+
+  const setRef = (ref: RiveViewRef) => {
+    viewRef.current = ref;
+    if (userHybridRef?.f) {
+      userHybridRef.f(ref);
+    }
+  };
+
+  return (
+    <NitroRiveView
+      {...rest}
+      onError={{ f: wrappedOnError }}
+      hybridRef={{ f: setRef }}
+    />
+  );
 }