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

package/ios/RCTSwiftLog.m

@@ -0,0 +1,38 @@
+//
+//  RCTSwiftLog.m
+//
+//
+//
+
+#import <React/RCTLog.h>
+
+#import "RCTSwiftLog.h"
+
+@implementation RCTSwiftLog
+
++ (void)info:(NSString *)message file:(NSString *)file line:(NSUInteger)line
+{
+  _RCTLogNativeInternal(RCTLogLevelInfo, file.UTF8String, (int)line, @"%@", message);
+}
+
++ (void)warn:(NSString *)message file:(NSString *)file line:(NSUInteger)line
+{
+  _RCTLogNativeInternal(RCTLogLevelWarning, file.UTF8String, (int)line, @"%@", message);
+}
+
++ (void)error:(NSString *)message file:(NSString *)file line:(NSUInteger)line
+{
+  _RCTLogNativeInternal(RCTLogLevelError, file.UTF8String, (int)line, @"%@", message);
+}
+
++ (void)log:(NSString *)message file:(NSString *)file line:(NSUInteger)line
+{
+  _RCTLogNativeInternal(RCTLogLevelInfo, file.UTF8String, (int)line, @"%@", message);
+}
+
++ (void)trace:(NSString *)message file:(NSString *)file line:(NSUInteger)line
+{
+  _RCTLogNativeInternal(RCTLogLevelTrace, file.UTF8String, (int)line, @"%@", message);
+}
+
+@end

package/ios/ReferencedAssetLoader.swift

@@ -0,0 +1,145 @@
+import NitroModules
+import RiveRuntime
+
+struct FileAndCache {
+  var file: RiveFile
+  var cache: [String: RiveFileAsset]
+}
+
+func createAssetFileError(_ assetName: String) -> NitroRiveError {
+  return NitroRiveError.fileNotFound(message: "Could not load Rive asset: \(assetName)")
+}
+
+final class ReferencedAssetLoader {
+  private func handleRiveError(error: Error) {
+    RCTLogError("\(error)")
+  }
+
+  private func processAssetBytes(
+    _ data: Data, asset: RiveFileAsset, factory: RiveFactory, completion: @escaping () -> Void
+  ) {
+    if data.isEmpty == true {
+      completion()
+      return
+    }
+    DispatchQueue.global(qos: .background).async {
+      switch asset {
+      case let imageAsset as RiveImageAsset:
+        let decodedImage = factory.decodeImage(data)
+        DispatchQueue.main.async {
+          imageAsset.renderImage(decodedImage)
+          completion()
+        }
+      case let fontAsset as RiveFontAsset:
+        let decodedFont = factory.decodeFont(data)
+        DispatchQueue.main.async {
+          fontAsset.font(decodedFont)
+          completion()
+        }
+      case let audioAsset as RiveAudioAsset:
+        guard let decodedAudio = factory.decodeAudio(data) else {
+          DispatchQueue.main.async {
+            completion()
+          }
+          return
+        }
+        DispatchQueue.main.async {
+          audioAsset.audio(decodedAudio)
+          completion()
+        }
+      default:
+        DispatchQueue.main.async {
+          completion()
+        }
+      }
+    }
+  }
+
+  private func handlePreloadedImage(
+    _ image: any HybridRiveImageSpec, asset: RiveFileAsset, completion: @escaping () -> Void
+  ) {
+    guard let imageAsset = asset as? RiveImageAsset,
+      let hybridImage = image as? HybridRiveImage
+    else {
+      completion()
+      return
+    }
+
+    imageAsset.renderImage(hybridImage.renderImage)
+    completion()
+  }
+
+  private func loadAssetInternal(
+    source: ResolvedReferencedAsset, asset: RiveFileAsset, factory: RiveFactory,
+    completion: @escaping () -> Void
+  ) {
+    if let preloadedImage = source.image {
+      handlePreloadedImage(preloadedImage, asset: asset, completion: completion)
+      return
+    }
+
+    let dataSource: DataSource
+    do {
+      guard let resolved = try DataSourceResolver.resolve(from: source) else {
+        completion()
+        return
+      }
+      dataSource = resolved
+    } catch {
+      handleRiveError(error: error)
+      completion()
+      return
+    }
+
+    Task {
+      do {
+        let data = try await dataSource.createLoader().load(from: dataSource)
+        await MainActor.run {
+          self.processAssetBytes(data, asset: asset, factory: factory, completion: completion)
+        }
+      } catch {
+        await MainActor.run {
+          self.handleRiveError(error: error)
+          completion()
+        }
+      }
+    }
+  }
+
+  func loadAsset(
+    source: ResolvedReferencedAsset, asset: RiveFileAsset, factory: RiveFactory,
+    completion: @escaping () -> Void
+  ) {
+    loadAssetInternal(source: source, asset: asset, factory: factory, completion: completion)
+  }
+
+  func createCustomLoader(
+    referencedAssets: ReferencedAssetsType?, cache: SendableRef<ReferencedAssetCache>,
+    factory factoryOut: SendableRef<RiveFactory?>,
+    fileRef: SendableRef<RiveFile?>
+  )
+    -> LoadAsset?
+  {
+    guard let referencedAssets = referencedAssets, let referencedAssets = referencedAssets.data
+    else {
+      return nil
+    }
+    return { (asset: RiveFileAsset, _: Data, factory: RiveFactory) -> Bool in
+      let assetByUniqueName = referencedAssets[asset.uniqueName()]
+      guard let assetData = assetByUniqueName ?? referencedAssets[asset.name()] else {
+        return false
+      }
+
+      cache.value[asset.uniqueName()] = asset
+      factoryOut.value = factory
+
+      self.loadAssetInternal(
+        source: assetData, asset: asset, factory: factory,
+        completion: {
+          withExtendedLifetime(fileRef) {}
+        })
+
+      return true
+    }
+  }
+}

package/ios/Rive.swift

@@ -0,0 +1,5 @@
+class Rive: HybridRiveSpec {
+    public func multiply(a: Double, b: Double) throws -> Double {
+        return a * b
+    }
+}

package/ios/RiveReactNativeView.swift

@@ -0,0 +1,325 @@
+import NitroModules
+import RiveRuntime
+import UIKit
+
+protocol RiveViewSource: AnyObject {
+  func registerView(_ view: RiveReactNativeView)
+  func unregisterView(_ view: RiveReactNativeView)
+}
+
+enum BindData {
+  case none
+  case auto
+  case instance(RiveDataBindingViewModel.Instance)
+  case byName(String)
+}
+
+struct ViewConfiguration {
+  let artboardName: String?
+  let stateMachineName: String?
+  let autoPlay: Bool
+  let riveFile: RiveFile
+  let viewSource: RiveViewSource?
+  let alignment: RiveRuntime.RiveAlignment
+  let fit: RiveRuntime.RiveFit
+  let layoutScaleFactor: Double
+  let bindData: BindData
+}
+
+enum NitroRiveError: Error {
+  case instanceNotFound(message: String)
+  case fileNotFound(message: String)
+}
+
+class RiveReactNativeView: UIView, RiveStateMachineDelegate {
+  // MARK: Internal Properties
+  private var riveView: RiveView?
+  private var baseViewModel: RiveViewModel?
+  private var eventListeners: [(UnifiedRiveEvent) -> Void] = []
+  private var viewReadyContinuation: CheckedContinuation<Void, Never>?
+  private var isViewReady = false
+  private weak var viewSource: RiveViewSource?
+
+  // MARK: Public Config Properties
+  var autoPlay: Bool = true
+
+  // MARK: - Public Methods
+
+  func awaitViewReady() async -> Bool {
+    if !isViewReady {
+      await withCheckedContinuation { continuation in
+        viewReadyContinuation = continuation
+      }
+      return true
+    }
+    return true
+  }
+
+  func configure(_ config: ViewConfiguration, dataBindingChanged: Bool = false, reload: Bool = false, initialUpdate: Bool = false) throws {
+    if reload {
+      cleanup()
+      let model = RiveModel(riveFile: config.riveFile)
+      baseViewModel = RiveViewModel(model, stateMachineName: config.stateMachineName, autoPlay: config.autoPlay, artboardName: config.artboardName)
+      createViewFromViewModel()
+
+      if let viewSource = config.viewSource {
+        self.viewSource = viewSource
+        viewSource.registerView(self)
+      }
+    }
+
+    baseViewModel?.alignment = config.alignment
+    baseViewModel?.fit = config.fit
+    baseViewModel?.autoPlay = config.autoPlay
+    baseViewModel?.layoutScaleFactor = config.layoutScaleFactor
+
+    if !isViewReady {
+      isViewReady = true
+      viewReadyContinuation?.resume()
+      viewReadyContinuation = nil
+    }
+
+    if dataBindingChanged || initialUpdate {
+      try applyDataBinding(config.bindData)
+    }
+  }
+
+  func bindViewModelInstance(viewModelInstance: RiveDataBindingViewModel.Instance) {
+    baseViewModel?.riveModel?.stateMachine?.bind(viewModelInstance: viewModelInstance)
+  }
+
+  func getViewModelInstance() -> RiveDataBindingViewModel.Instance? {
+    return baseViewModel?.riveModel?.stateMachine?.viewModelInstance
+  }
+
+  func applyDataBinding(_ bindData: BindData) throws {
+    let stateMachine = baseViewModel?.riveModel?.stateMachine
+    let artboard = baseViewModel?.riveModel?.artboard
+
+    switch bindData {
+    case .none:
+      baseViewModel?.riveModel?.disableAutoBind()
+
+    case .auto:
+      baseViewModel?.riveModel?.enableAutoBind { _ in
+        // Auto-bind callback
+      }
+
+    case .byName(let name):
+      guard let artboard = artboard,
+        let riveFile = baseViewModel?.riveModel?.riveFile,
+        let viewModel = riveFile.defaultViewModel(for: artboard),
+        let instance = viewModel.createInstance(fromName: name)
+      else {
+        throw NitroRiveError.instanceNotFound(message: "\(name) instance not found")
+      }
+      stateMachine?.bind(viewModelInstance: instance)
+      // this should be added if we support only playing artboards on their own - https://github.com/rive-app/rive-nitro-react-native/pull/23#discussion_r2534698281
+      // artboard.bind(viewModelInstance: instance)
+
+    case .instance(let instance):
+      stateMachine?.bind(viewModelInstance: instance)
+      // this should be added if we support only playing artboards on their own - https://github.com/rive-app/rive-nitro-react-native/pull/23#discussion_r2534698281
+      // artboard?.bind(viewModelInstance: instance)
+    }
+    play()
+  }
+
+  @MainActor
+  func play() {
+    baseViewModel?.play()
+  }
+
+  @MainActor
+  func pause() {
+    baseViewModel?.pause()
+  }
+
+  @MainActor
+  func reset() {
+    baseViewModel?.reset()
+  }
+  
+  func playIfNeeded() {
+    if let baseViewModel = baseViewModel, (baseViewModel.isPlaying == false) {
+      Task {
+        baseViewModel.play()
+      }
+    }
+   }
+
+  func refreshAfterAssetChange() {
+    if baseViewModel?.isPlaying == false {
+      play()
+    }
+  }
+
+  func addEventListener(_ onEvent: @escaping (UnifiedRiveEvent) -> Void) {
+    eventListeners.append(onEvent)
+  }
+
+  func removeEventListeners() {
+    eventListeners.removeAll()
+  }
+
+  func setNumberInputValue(name: String, value: Float, path: String?) throws {
+    try handleInput(name: name, path: path, type: .number) { (input: RiveRuntime.RiveSMINumber) in
+      input.setValue(value)
+    }
+  }
+
+  func getNumberInputValue(name: String, path: String?) throws -> Float {
+    try handleInput(name: name, path: path, type: .number) { (input: RiveRuntime.RiveSMINumber) in
+      input.value()
+    }
+  }
+
+  func setBooleanInputValue(name: String, value: Bool, path: String?) throws {
+    try handleInput(name: name, path: path, type: .boolean) { (input: RiveRuntime.RiveSMIBool) in
+      input.setValue(value)
+    }
+  }
+
+  func getBooleanInputValue(name: String, path: String?) throws -> Bool {
+    try handleInput(name: name, path: path, type: .boolean) { (input: RiveRuntime.RiveSMIBool) in
+      input.value()
+    }
+  }
+
+  func triggerInput(name: String, path: String?) throws {
+    try handleInput(name: name, path: path, type: .trigger) { (input: RiveRuntime.RiveSMITrigger) in
+      input.fire()
+    }
+  }
+
+  func setTextRunValue(name: String, value: String, path: String?) throws {
+    let textRun = try textRunOptionPath(name: name, path: path)
+    textRun.setText(value)
+  }
+
+  func getTextRunValue(name: String, path: String?) throws -> String {
+    let textRun = try textRunOptionPath(name: name, path: path)
+    return textRun.text()
+  }
+
+  private func textRunOptionPath(name: String, path: String?) throws -> RiveRuntime.RiveTextValueRun {
+    let textRun: RiveRuntime.RiveTextValueRun?
+    if let path = path {
+      textRun = baseViewModel?.riveModel?.artboard?.textRun(name, path: path)
+    } else {
+      textRun = baseViewModel?.riveModel?.artboard?.textRun(name)
+    }
+
+    guard let textRun = textRun else {
+      throw RuntimeError.error(
+        withMessage: "Could not find text run `\(name)`\(path.map { " at path `\($0)`" } ?? "")")
+    }
+
+    return textRun
+  }
+
+  // MARK: - Internal
+  deinit {
+    cleanup()
+  }
+
+  private func createViewFromViewModel() {
+    riveView = baseViewModel?.createRiveView()
+
+    if let riveView = riveView {
+      riveView.translatesAutoresizingMaskIntoConstraints = false
+      addSubview(riveView)
+      riveView.stateMachineDelegate = self
+      NSLayoutConstraint.activate([
+        riveView.leadingAnchor.constraint(equalTo: leadingAnchor),
+        riveView.trailingAnchor.constraint(equalTo: trailingAnchor),
+        riveView.topAnchor.constraint(equalTo: topAnchor),
+        riveView.bottomAnchor.constraint(equalTo: bottomAnchor)
+      ])
+    }
+  }
+
+  private func cleanup() {
+    riveView?.removeFromSuperview()
+    riveView?.stateMachineDelegate = nil
+    riveView = nil
+    baseViewModel = nil
+    if let viewSource = viewSource {
+      viewSource.unregisterView(self)
+      self.viewSource = nil
+    }
+  }
+
+  @objc func onRiveEventReceived(onRiveEvent riveEvent: RiveRuntime.RiveEvent) {
+    let eventType = UnifiedRiveEvent(
+      name: riveEvent.name(),
+      type: riveEvent is RiveRuntime.RiveOpenUrlEvent
+        ? RiveEventType.openurl : RiveEventType.general,
+      delay: Double(riveEvent.delay()),
+      properties: convertEventProperties(riveEvent.properties()),
+      url: (riveEvent as? RiveRuntime.RiveOpenUrlEvent)?.url(),
+      target: (riveEvent as? RiveRuntime.RiveOpenUrlEvent)?.target()
+    )
+
+    for listener in eventListeners {
+      listener(eventType)
+    }
+  }
+
+  private func convertEventProperties(_ properties: [String: Any]?) -> [String:
+    EventPropertiesOutput]? {
+    guard let properties = properties else { return nil }
+
+    var newMap: [String: EventPropertiesOutput] = [:]
+
+    for (key, value) in properties {
+      if let string = value as? String {
+        newMap[key] = .string(string)
+      } else if let number = value as? NSNumber {
+        newMap[key] = .number(number.doubleValue)
+      } else if let boolean = value as? Bool {
+        newMap[key] = .boolean(boolean)
+      }
+    }
+
+    return newMap
+  }
+
+  private enum InputType {
+    case number
+    case boolean
+    case trigger
+  }
+
+  private func handleInput<P: RiveRuntime.RiveSMIInput, T>(
+    name: String, path: String?, type: InputType, onSuccess: (P) throws -> T
+  ) throws -> T {
+    let input: P?
+    if let path = path {
+      switch type {
+      case .number:
+        input = baseViewModel?.riveModel?.artboard?.getNumber(name, path: path) as? P
+      case .boolean:
+        input = baseViewModel?.riveModel?.artboard?.getBool(name, path: path) as? P
+      case .trigger:
+        input = baseViewModel?.riveModel?.artboard?.getTrigger(name, path: path) as? P
+      }
+    } else {
+      switch type {
+      case .number:
+        input = baseViewModel?.numberInput(named: name) as? P
+      case .boolean:
+        input = baseViewModel?.boolInput(named: name) as? P
+      case .trigger:
+        input = baseViewModel?.riveModel?.stateMachine?.getTrigger(name) as? P
+      }
+    }
+
+    guard let input = input else {
+      throw RuntimeError.error(
+        withMessage: "Could not find input `\(name)`\(path.map { " at path `\($0)`" } ?? "")")
+    }
+
+    return try onSuccess(input)
+  }
+}

package/ios/Utils.swift

@@ -0,0 +1,15 @@
+final class Weak<T: AnyObject> {
+  weak var value: T?
+
+  init(_ value: T) {
+    self.value = value
+  }
+}
+
+final class SendableRef<T: Sendable>: @unchecked Sendable {
+  var value: T
+
+  init(_ value: T) {
+    self.value = value
+  }
+}

package/lib/module/core/Alignment.js

@@ -0,0 +1,42 @@
+"use strict";
+
+export let Alignment = /*#__PURE__*/function (Alignment) {
+  /**
+   * Aligns content to the top-left corner of the container
+   */
+  Alignment["TopLeft"] = "topLeft";
+  /**
+   * Centers content horizontally at the top of the container
+   */
+  Alignment["TopCenter"] = "topCenter";
+  /**
+   * Aligns content to the top-right corner of the container
+   */
+  Alignment["TopRight"] = "topRight";
+  /**
+   * Centers content vertically on the left side of the container
+   */
+  Alignment["CenterLeft"] = "centerLeft";
+  /**
+   * Centers content both horizontally and vertically in the container
+   */
+  Alignment["Center"] = "center";
+  /**
+   * Centers content vertically on the right side of the container
+   */
+  Alignment["CenterRight"] = "centerRight";
+  /**
+   * Aligns content to the bottom-left corner of the container
+   */
+  Alignment["BottomLeft"] = "bottomLeft";
+  /**
+   * Centers content horizontally at the bottom of the container
+   */
+  Alignment["BottomCenter"] = "bottomCenter";
+  /**
+   * Aligns content to the bottom-right corner of the container
+   */
+  Alignment["BottomRight"] = "bottomRight";
+  return Alignment;
+}({});
+//# sourceMappingURL=Alignment.js.map

package/lib/module/core/Alignment.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Alignment"],"sourceRoot":"../../../src","sources":["core/Alignment.ts"],"mappings":";;AAAA,WAAYA,SAAS,0BAATA,SAAS;EACnB;AACF;AACA;EAHYA,SAAS;EAMnB;AACF;AACA;EARYA,SAAS;EAWnB;AACF;AACA;EAbYA,SAAS;EAgBnB;AACF;AACA;EAlBYA,SAAS;EAqBnB;AACF;AACA;EAvBYA,SAAS;EA0BnB;AACF;AACA;EA5BYA,SAAS;EA+BnB;AACF;AACA;EAjCYA,SAAS;EAoCnB;AACF;AACA;EAtCYA,SAAS;EAyCnB;AACF;AACA;EA3CYA,SAAS;EAAA,OAATA,SAAS;AAAA","ignoreList":[]}

package/lib/module/core/Errors.js

@@ -0,0 +1,13 @@
+"use strict";
+
+export let RiveErrorType = /*#__PURE__*/function (RiveErrorType) {
+  RiveErrorType[RiveErrorType["Unknown"] = 0] = "Unknown";
+  RiveErrorType[RiveErrorType["FileNotFound"] = 1] = "FileNotFound";
+  RiveErrorType[RiveErrorType["MalformedFile"] = 2] = "MalformedFile";
+  RiveErrorType[RiveErrorType["IncorrectArtboardName"] = 3] = "IncorrectArtboardName";
+  RiveErrorType[RiveErrorType["IncorrectStateMachineName"] = 4] = "IncorrectStateMachineName";
+  RiveErrorType[RiveErrorType["ViewModelInstanceNotFound"] = 6] = "ViewModelInstanceNotFound";
+  RiveErrorType[RiveErrorType["IncorrectStateMachineInputName"] = 8] = "IncorrectStateMachineInputName";
+  return RiveErrorType;
+}({});
+//# sourceMappingURL=Errors.js.map

package/lib/module/core/Errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RiveErrorType"],"sourceRoot":"../../../src","sources":["core/Errors.ts"],"mappings":";;AAAA,WAAYA,aAAa,0BAAbA,aAAa;EAAbA,aAAa,CAAbA,aAAa;EAAbA,aAAa,CAAbA,aAAa;EAAbA,aAAa,CAAbA,aAAa;EAAbA,aAAa,CAAbA,aAAa;EAAbA,aAAa,CAAbA,aAAa;EAAbA,aAAa,CAAbA,aAAa;EAAbA,aAAa,CAAbA,aAAa;EAAA,OAAbA,aAAa;AAAA","ignoreList":[]}

package/lib/module/core/Events.js

@@ -0,0 +1,8 @@
+"use strict";
+
+export let RiveEventType = /*#__PURE__*/function (RiveEventType) {
+  RiveEventType[RiveEventType["General"] = 0] = "General";
+  RiveEventType[RiveEventType["OpenUrl"] = 1] = "OpenUrl";
+  return RiveEventType;
+}({});
+//# sourceMappingURL=Events.js.map

package/lib/module/core/Events.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RiveEventType"],"sourceRoot":"../../../src","sources":["core/Events.ts"],"mappings":";;AAAA,WAAYA,aAAa,0BAAbA,aAAa;EAAbA,aAAa,CAAbA,aAAa;EAAbA,aAAa,CAAbA,aAAa;EAAA,OAAbA,aAAa;AAAA","ignoreList":[]}

package/lib/module/core/Fit.js

@@ -0,0 +1,51 @@
+"use strict";
+
+export let Fit = /*#__PURE__*/function (Fit) {
+  /**
+   * Rive content will fill the available view. If the aspect ratios differ,
+   * then the Rive content will be stretched.
+   */
+  Fit[Fit["Fill"] = 0] = "Fill";
+  /**
+   * Rive content will be contained within the view, preserving the aspect
+   * ratio. If the ratios differ, then a portion of the view will be unused
+   */
+  Fit[Fit["Contain"] = 1] = "Contain";
+  /**
+   * Rive will cover the view, preserving the aspect ratio. If the Rive
+   * content has a different ratio to the view, then the Rive content will be
+   * clipped.
+   */
+  Fit[Fit["Cover"] = 2] = "Cover";
+  /**
+   * Rive content will fill to the width of the view. This may result in
+   * clipping or unfilled view space.
+   */
+  Fit[Fit["FitWidth"] = 3] = "FitWidth";
+  /**
+   * Rive content will fill to the height of the view. This may result in
+   * clipping or unfilled view space.
+   */
+  Fit[Fit["FitHeight"] = 4] = "FitHeight";
+  /**
+   * Rive content will render to the size of its artboard, which may result
+   * in clipping or unfilled view space.
+   */
+  Fit[Fit["None"] = 5] = "None";
+  /**
+   * Rive content is scaled down to the size of the view, preserving the
+   * aspect ratio. This is equivalent to Contain when the content is larger
+   * than the canvas. If the canvas is larger, then ScaleDown will not scale
+   * up.
+   */
+  Fit[Fit["ScaleDown"] = 6] = "ScaleDown";
+  /**
+   * Rive content will be resized automatically based on layout constraints of
+   * the artboard to match the underlying widget size.
+   *
+   * @see [Responsive Layout](https://rive.app/community/doc/layout/docBl81zd1GB#responsive-layout)
+   */
+  Fit[Fit["Layout"] = 7] = "Layout";
+  return Fit;
+}({});
+//# sourceMappingURL=Fit.js.map

package/lib/module/core/Fit.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Fit"],"sourceRoot":"../../../src","sources":["core/Fit.ts"],"mappings":";;AAAA,WAAYA,GAAG,0BAAHA,GAAG;EACb;AACF;AACA;AACA;EAJYA,GAAG,CAAHA,GAAG;EAOb;AACF;AACA;AACA;EAVYA,GAAG,CAAHA,GAAG;EAab;AACF;AACA;AACA;AACA;EAjBYA,GAAG,CAAHA,GAAG;EAoBb;AACF;AACA;AACA;EAvBYA,GAAG,CAAHA,GAAG;EA0Bb;AACF;AACA;AACA;EA7BYA,GAAG,CAAHA,GAAG;EAgCb;AACF;AACA;AACA;EAnCYA,GAAG,CAAHA,GAAG;EAsCb;AACF;AACA;AACA;AACA;AACA;EA3CYA,GAAG,CAAHA,GAAG;EA8Cb;AACF;AACA;AACA;AACA;AACA;EAnDYA,GAAG,CAAHA,GAAG;EAAA,OAAHA,GAAG;AAAA","ignoreList":[]}

package/lib/module/core/NitroRiveViewComponent.js

@@ -0,0 +1,6 @@
+"use strict";
+
+import { getHostComponent } from 'react-native-nitro-modules';
+import RiveViewConfig from '../../nitrogen/generated/shared/json/RiveViewConfig.json';
+export const NitroRiveView = getHostComponent('RiveView', () => RiveViewConfig);
+//# sourceMappingURL=NitroRiveViewComponent.js.map

package/lib/module/core/NitroRiveViewComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getHostComponent","RiveViewConfig","NitroRiveView"],"sourceRoot":"../../../src","sources":["core/NitroRiveViewComponent.ts"],"mappings":";;AAAA,SACEA,gBAAgB,QAEX,4BAA4B;AAMnC,OAAOC,cAAc,MAAM,0DAA0D;AAErF,OAAO,MAAMC,aAAa,GAAGF,gBAAgB,CAG3C,UAAU,EAAE,MAAMC,cAAc,CAGjC","ignoreList":[]}

package/lib/module/core/ReferencedAssets.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=ReferencedAssets.js.map

package/lib/module/core/ReferencedAssets.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["core/ReferencedAssets.ts"],"mappings":"","ignoreList":[]}