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

package/ios/HybridRiveView.swift

@@ -0,0 +1,284 @@
+import Foundation
+import NitroModules
+import RiveRuntime
+import UIKit
+
+private struct DefaultConfiguration {
+  static let autoPlay = true
+  static let alignment = RiveAlignment.center
+  static let fit = RiveFit.contain
+  static let layoutScaleFactor = RiveRuntime.RiveViewModel.layoutScaleFactorAutomatic
+}
+
+typealias HybridDataBindMode = Variant__any_HybridViewModelInstanceSpec__DataBindMode_DataBindByName
+
+extension Optional
+where Wrapped == HybridDataBindMode {
+  func toDataBingMode() throws -> BindData {
+    guard let value = self else {
+      return .auto
+    }
+
+    switch value {
+    case .first(let viewModelInstance):
+      if let instance = (viewModelInstance as? HybridViewModelInstance)?.viewModelInstance {
+        return .instance(instance)
+      } else {
+        throw RuntimeError.error(withMessage: "Invalid ViewModelInstance")
+      }
+    case .second(let mode):
+      switch mode {
+      case .auto:
+        return .auto
+      case .none:
+        return .none
+      }
+    case .third(let dataBindByName):
+      return .byName(dataBindByName.byName)
+    }
+  }
+  
+  /// Check if two HybridDataBindMode values are semantically equal
+  func isEqual(to other: HybridDataBindMode?) -> Bool {
+    guard let lhs = self, let rhs = other else {
+      return self == nil && other == nil
+    }
+    
+    switch (lhs, rhs) {
+    case (.first(let lhsInstance), .first(let rhsInstance)):
+      // Compare ViewModelInstance references
+      let lhsVMI = (lhsInstance as? HybridViewModelInstance)?.viewModelInstance
+      let rhsVMI = (rhsInstance as? HybridViewModelInstance)?.viewModelInstance
+      return lhsVMI === rhsVMI
+      
+    case (.second(let lhsMode), .second(let rhsMode)):
+      // Compare DataBindMode enums
+      return lhsMode == rhsMode
+      
+    case (.third(let lhsByName), .third(let rhsByName)):
+      // Compare byName strings
+      return lhsByName.byName == rhsByName.byName
+      
+    default:
+      return false
+    }
+  }
+}
+
+class HybridRiveView: HybridRiveViewSpec {
+  func play() throws -> NitroModules.Promise<Void> {
+    return Promise.async {
+      try await self.getRiveView().play()
+    }
+  }
+
+  func pause() throws -> NitroModules.Promise<Void> {
+    return Promise.async {
+      try await self.getRiveView().pause()
+    }
+  }
+
+  func reset() throws -> NitroModules.Promise<Void> {
+    return Promise.async {
+      try await self.getRiveView().reset()
+    }
+  }
+  
+  func playIfNeeded() {
+    try? self.getRiveView().playIfNeeded()
+  }
+
+  // MARK: View Props
+  var dataBind: HybridDataBindMode? {
+    didSet {
+      if !dataBind.isEqual(to: oldValue) {
+        dataBindingChanged = true
+      }
+    }
+  }
+
+  var artboardName: String? { didSet { needsReload = true } }
+  var stateMachineName: String? { didSet { needsReload = true } }
+  var autoPlay: Bool? { didSet { needsReload = true } }
+  var file: (any HybridRiveFileSpec) = HybridRiveFile() {
+    didSet { needsReload = true }
+  }
+  var alignment: Alignment?
+  var fit: Fit?
+  var layoutScaleFactor: Double?
+  var onError: (RiveError) -> Void = { _ in }
+
+  func awaitViewReady() throws -> Promise<Bool> {
+    return Promise.async { [self] in
+      return try await getRiveView().awaitViewReady()
+    }
+  }
+
+  func bindViewModelInstance(viewModelInstance: (any HybridViewModelInstanceSpec)) throws {
+    guard let viewModelInstance = (viewModelInstance as? HybridViewModelInstance)?.viewModelInstance
+    else { return }
+    try getRiveView().bindViewModelInstance(viewModelInstance: viewModelInstance)
+  }
+
+  func getViewModelInstance() throws -> (any HybridViewModelInstanceSpec)? {
+    guard let viewModelInstance = try getRiveView().getViewModelInstance() else { return nil }
+    return HybridViewModelInstance(viewModelInstance: viewModelInstance)
+  }
+
+  func onEventListener(onEvent: @escaping (UnifiedRiveEvent) -> Void) throws {
+    try getRiveView().addEventListener(onEvent)
+  }
+
+  func removeEventListeners() throws { try getRiveView().removeEventListeners() }
+
+  func setNumberInputValue(name: String, value: Double, path: String?) throws {
+    try getRiveView().setNumberInputValue(name: name, value: Float(value), path: path)
+  }
+
+  func getNumberInputValue(name: String, path: String?) throws -> Double {
+    return try Double(getRiveView().getNumberInputValue(name: name, path: path))
+  }
+
+  func setBooleanInputValue(name: String, value: Bool, path: String?) throws {
+    try getRiveView().setBooleanInputValue(name: name, value: value, path: path)
+  }
+
+  func getBooleanInputValue(name: String, path: String?) throws -> Bool {
+    return try getRiveView().getBooleanInputValue(name: name, path: path)
+  }
+
+  func triggerInput(name: String, path: String?) throws {
+    try getRiveView().triggerInput(name: name, path: path)
+  }
+
+  func setTextRunValue(name: String, value: String, path: String?) throws {
+    try getRiveView().setTextRunValue(name: name, value: value, path: path)
+  }
+
+  func getTextRunValue(name: String, path: String?) throws -> String {
+    return try getRiveView().getTextRunValue(name: name, path: path)
+  }
+
+  // MARK: Views
+  var view: UIView = RiveReactNativeView()
+  func getRiveView() throws -> RiveReactNativeView {
+    guard let riveView = view as? RiveReactNativeView else {
+      throw RuntimeError.error(withMessage: "RiveReactNativeView is null or not configured")
+    }
+    return riveView
+  }
+
+  // MARK: Update
+  func afterUpdate() {
+    logged(tag: "HybridRiveView", note: "afterUpdate") {
+      guard let hybridFile = file as? HybridRiveFile,
+        let file = hybridFile.riveFile
+      else { return }
+
+      let config = ViewConfiguration(
+        artboardName: artboardName,
+        stateMachineName: stateMachineName,
+        autoPlay: autoPlay ?? DefaultConfiguration.autoPlay,
+        riveFile: file,
+        viewSource: hybridFile,
+        alignment: convertAlignment(alignment) ?? DefaultConfiguration.alignment,
+        fit: convertFit(fit) ?? DefaultConfiguration.fit,
+        layoutScaleFactor: layoutScaleFactor ?? DefaultConfiguration.layoutScaleFactor,
+        bindData: try dataBind.toDataBingMode()
+      )
+
+      let riveView = try getRiveView()
+      try riveView.configure(
+        config, dataBindingChanged: dataBindingChanged, reload: needsReload,
+        initialUpdate: initialUpdate)
+      needsReload = false
+      dataBindingChanged = false
+      initialUpdate = false
+    }
+  }
+
+  // MARK: Internal State
+  private var needsReload = false
+  private var dataBindingChanged = false
+  private var initialUpdate = true
+
+  // MARK: Helpers
+  private func convertAlignment(_ alignment: Alignment?) -> RiveAlignment? {
+    guard let alignment = alignment else { return nil }
+
+    switch alignment {
+    case .topleft: return .topLeft
+    case .topcenter: return .topCenter
+    case .topright: return .topRight
+    case .centerleft: return .centerLeft
+    case .center: return .center
+    case .centerright: return .centerRight
+    case .bottomleft: return .bottomLeft
+    case .bottomcenter: return .bottomCenter
+    case .bottomright: return .bottomRight
+    }
+  }
+
+  private func convertFit(_ fit: Fit?) -> RiveFit? {
+    guard let fit = fit else { return nil }
+
+    switch fit {
+    case .fill: return .fill
+    case .contain: return .contain
+    case .cover: return .cover
+    case .fitwidth: return .fitWidth
+    case .fitheight: return .fitHeight
+    case .none: return .noFit
+    case .scaledown: return .scaleDown
+    case .layout: return .layout
+    }
+  }
+}
+
+extension HybridRiveView {
+  func logged(tag: String, note: String? = nil, _ fn: () throws -> Void) {
+    do {
+      return try fn()
+    } catch let e {
+      let (errorType, errorDescription) = detectErrorType(e)
+      let noteString = note.map { " \($0)" } ?? ""
+      let errorMessage = "[RIVE] \(tag)\(noteString) \(errorDescription)"
+
+      let riveError = RiveError(
+        message: errorMessage,
+        type: errorType
+      )
+      onError(riveError)
+    }
+  }
+
+  private func detectErrorType(_ error: Error) -> (RiveErrorType, String) {
+    switch error {
+    case NitroRiveError.instanceNotFound(let message):
+      return (.viewmodelinstancenotfound, message)
+    case NitroRiveError.fileNotFound(let message):
+      return (.filenotfound, message)
+    default:
+      break
+    }
+
+    let nsError = error as NSError
+    let message = nsError.localizedDescription
+
+    // RiveErrorCode from RiveRuntime
+    switch nsError.code {
+    case RiveErrorCode.noArtboardFound.rawValue:
+      return (.incorrectartboardname, message)
+    case RiveErrorCode.noStateMachineFound.rawValue:
+      return (.incorrectstatemachinename, message)
+    case RiveErrorCode.noAnimationFound.rawValue:
+      return (.unknown, message)
+    case RiveErrorCode.malformedFile.rawValue:
+      return (.malformedfile, message)
+    case RiveErrorCode.noStateMachineInputFound.rawValue:
+      return (.incorrectstatemachineinputname, message)
+    default:
+      return (.unknown, message)
+    }
+  }
+}

package/ios/HybridViewModel.swift

@@ -0,0 +1,46 @@
+import RiveRuntime
+
+class HybridViewModel: HybridViewModelSpec {
+  let viewModel: RiveDataBindingViewModel?
+  
+  init(viewModel: RiveDataBindingViewModel) {
+    self.viewModel = viewModel
+  }
+  
+  override init() {
+    self.viewModel = nil
+    super.init()
+  }
+  
+  var propertyCount: Double { Double(viewModel?.propertyCount ?? 0) }
+  
+  var instanceCount: Double { Double(viewModel?.instanceCount ?? 0) }
+  
+  var modelName: String { viewModel?.name ?? "" }
+  
+  func createInstanceByIndex(index: Double) throws -> (any HybridViewModelInstanceSpec)? {
+    guard let viewModel = viewModel,
+          let vmi = viewModel.createInstance(fromIndex: UInt(index)) else { return nil }
+    return HybridViewModelInstance(viewModelInstance: vmi)
+  }
+  
+  func createInstanceByName(name: String) throws -> (any HybridViewModelInstanceSpec)? {
+    guard let viewModel = viewModel,
+          let vmi = viewModel.createInstance(fromName: name) else { return nil }
+    return HybridViewModelInstance(viewModelInstance: vmi)
+  }
+  
+  func createDefaultInstance() throws -> (any HybridViewModelInstanceSpec)? {
+    guard let viewModel = viewModel,
+          let vmi = viewModel.createDefaultInstance() else {
+      return nil
+    }
+    return HybridViewModelInstance(viewModelInstance: vmi)
+  }
+  
+  func createInstance() throws -> (any HybridViewModelInstanceSpec)? {
+    guard let viewModel = viewModel,
+          let vmi = viewModel.createInstance() else { return nil }
+    return HybridViewModelInstance(viewModelInstance: vmi)
+  }
+}

package/ios/HybridViewModelBooleanProperty.swift

@@ -0,0 +1,29 @@
+import NitroModules
+import RiveRuntime
+
+class HybridViewModelBooleanProperty: HybridViewModelBooleanPropertySpec, ValuedPropertyProtocol {
+  var property: BooleanPropertyType!
+  lazy var helper = PropertyListenerHelper(property: property!)
+  
+  init(property: BooleanPropertyType) {
+    self.property = property
+    super.init()
+  }
+  
+  /// ⚠️ DO NOT REMOVE
+  /// Nitro requires a parameterless initializer for JS bridging.
+  /// This is invoked automatically during hybrid module construction.
+  /// Internally we always use `init(property:)`
+  override init() {
+    super.init()
+  }
+  
+  var value: Bool {
+    get {
+      return property.value
+    }
+    set {
+      property.value = newValue
+    }
+  }
+}

package/ios/HybridViewModelColorProperty.swift

@@ -0,0 +1,63 @@
+import NitroModules
+import RiveRuntime
+
+class HybridViewModelColorProperty: HybridViewModelColorPropertySpec, ValuedPropertyProtocol {
+  var property: ColorPropertyType!
+  lazy var helper = PropertyListenerHelper(property: property!)
+  
+  init(property: ColorPropertyType) {
+    self.property = property
+    super.init()
+  }
+  
+  /// ⚠️ DO NOT REMOVE
+  /// Nitro requires a parameterless initializer for JS bridging.
+  /// This is invoked automatically during hybrid module construction.
+  /// Internally we always use `init(property:)`
+  override init() {
+    super.init()
+  }
+  
+  var value: Double {
+    get {
+      return property.value.toHexDouble()
+    }
+    set {
+      property.value = UIColor(argb: Int(newValue))
+    }
+  }
+  
+  // Custom addListener because we need to convert UIColor → Double
+  func addListener(onChanged: @escaping (Double) -> Void) throws {
+    helper.addListener { (color: UIColor) in
+      onChanged(color.toHexDouble())
+    }
+  }
+}
+
+extension UIColor {
+  convenience init(argb: Int) {
+    let alpha = CGFloat((argb >> 24) & 0xFF) / 255.0
+    let red   = CGFloat((argb >> 16) & 0xFF) / 255.0
+    let green = CGFloat((argb >> 8) & 0xFF) / 255.0
+    let blue  = CGFloat(argb & 0xFF) / 255.0
+    
+    self.init(red: red, green: green, blue: blue, alpha: alpha)
+  }
+  
+  func toHexDouble() -> Double {
+    var red: CGFloat = 0
+    var green: CGFloat = 0
+    var blue: CGFloat = 0
+    var alpha: CGFloat = 0
+    
+    self.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
+    
+    let r = UInt32(red * 255)
+    let g = UInt32(green * 255)
+    let b = UInt32(blue * 255)
+    let a = UInt32(alpha * 255)
+    
+    return Double((a << 24) | (r << 16) | (g << 8) | b)
+  }
+}

package/ios/HybridViewModelEnumProperty.swift

@@ -0,0 +1,29 @@
+import NitroModules
+import RiveRuntime
+
+class HybridViewModelEnumProperty: HybridViewModelEnumPropertySpec, ValuedPropertyProtocol {
+  var property: EnumPropertyType!
+  lazy var helper = PropertyListenerHelper(property: property!)
+  
+  init(property: EnumPropertyType) {
+    self.property = property
+    super.init()
+  }
+  
+  /// ⚠️ DO NOT REMOVE
+  /// Nitro requires a parameterless initializer for JS bridging.
+  /// This is invoked automatically during hybrid module construction.
+  /// Internally we always use `init(property:)`
+  override init() {
+    super.init()
+  }
+  
+  var value: String {
+    get {
+      return property.value
+    }
+    set {
+      property.value = newValue
+    }
+  }
+}

package/ios/HybridViewModelImageProperty.swift

@@ -0,0 +1,31 @@
+import RiveRuntime
+
+class HybridViewModelImageProperty: HybridViewModelImagePropertySpec, ValuedPropertyProtocol {
+  func addListener(onChanged: @escaping () -> Void) throws {
+    try addListener(onChanged: { _ in onChanged() })
+  }
+  
+  var property: ImagePropertyType!
+  lazy var helper = PropertyListenerHelper(property: property!)
+
+  init(property: ImagePropertyType) {
+    self.property = property
+    super.init()
+  }
+
+  /// ⚠️ DO NOT REMOVE
+  /// Nitro requires a parameterless initializer for JS bridging.
+  /// This is invoked automatically during hybrid module construction.
+  /// Internally we always use `init(property:)`
+  override init() {
+    super.init()
+  }
+
+  func set(image: HybridRiveImageSpec?) throws {
+    if let hybridImage = image as? HybridRiveImage {
+      property.setValue(hybridImage.renderImage)
+    } else {
+      property.setValue(nil)
+    }
+  }
+}

package/ios/HybridViewModelInstance.swift

@@ -0,0 +1,51 @@
+import RiveRuntime
+
+class HybridViewModelInstance: HybridViewModelInstanceSpec {
+  let viewModelInstance: RiveDataBindingViewModel.Instance?
+  
+  init(viewModelInstance: RiveDataBindingViewModel.Instance) {
+    self.viewModelInstance = viewModelInstance
+  }
+  
+  override init() {
+    self.viewModelInstance = nil
+    super.init()
+  }
+  
+  var instanceName: String { viewModelInstance?.name ?? "" }
+  
+  func numberProperty(path: String) throws -> (any HybridViewModelNumberPropertySpec)? {
+    guard let property = viewModelInstance?.numberProperty(fromPath: path) else { return nil }
+    return HybridViewModelNumberProperty(property: property)
+  }
+  
+  func stringProperty(path: String) throws -> (any HybridViewModelStringPropertySpec)? {
+    guard let property = viewModelInstance?.stringProperty(fromPath: path) else { return nil }
+    return HybridViewModelStringProperty(property: property)
+  }
+  
+  func booleanProperty(path: String) throws -> (any HybridViewModelBooleanPropertySpec)? {
+    guard let property = viewModelInstance?.booleanProperty(fromPath: path) else { return nil }
+    return HybridViewModelBooleanProperty(property: property)
+  }
+  
+  func colorProperty(path: String) throws -> (any HybridViewModelColorPropertySpec)? {
+    guard let property = viewModelInstance?.colorProperty(fromPath: path) else { return nil }
+    return HybridViewModelColorProperty(property: property)
+  }
+  
+  func enumProperty(path: String) throws -> (any HybridViewModelEnumPropertySpec)? {
+    guard let property = viewModelInstance?.enumProperty(fromPath: path) else { return nil }
+    return HybridViewModelEnumProperty(property: property)
+  }
+  
+  func triggerProperty(path: String) throws -> (any HybridViewModelTriggerPropertySpec)? {
+    guard let property = viewModelInstance?.triggerProperty(fromPath: path) else { return nil }
+    return HybridViewModelTriggerProperty(property: property)
+  }
+
+  func imageProperty(path: String) throws -> (any HybridViewModelImagePropertySpec)? {
+    guard let property = viewModelInstance?.imageProperty(fromPath: path) else { return nil }
+    return HybridViewModelImageProperty(property: property)
+  }
+}

package/ios/HybridViewModelNumberProperty.swift

@@ -0,0 +1,35 @@
+import RiveRuntime
+
+class HybridViewModelNumberProperty: HybridViewModelNumberPropertySpec, ValuedPropertyProtocol {
+  var property: NumberPropertyType!
+  lazy var helper = PropertyListenerHelper(property: property!)
+
+  init(property: NumberPropertyType) {
+    self.property = property
+    super.init()
+  }
+
+  /// ⚠️ DO NOT REMOVE
+  /// Nitro requires a parameterless initializer for JS bridging.
+  /// This is invoked automatically during hybrid module construction.
+  /// Internally we always use `init(property:)`
+  override init() {
+    super.init()
+  }
+
+  var value: Double {
+    get {
+      return Double(property.value)
+    }
+    set {
+      property.value = Float(newValue)
+    }
+  }
+
+  // Custom addListener needed because ListenerValueType (Float) != ValueType (Double)
+  func addListener(onChanged: @escaping (Double) -> Void) throws {
+    helper.addListener { (value: Float) in
+      onChanged(Double(value))
+    }
+  }
+}

package/ios/HybridViewModelStringProperty.swift

@@ -0,0 +1,29 @@
+import NitroModules
+import RiveRuntime
+
+class HybridViewModelStringProperty: HybridViewModelStringPropertySpec, ValuedPropertyProtocol {
+  var property: StringPropertyType!
+  lazy var helper = PropertyListenerHelper(property: property!)
+  
+  init(property: StringPropertyType) {
+    self.property = property
+    super.init()
+  }
+  
+  /// ⚠️ DO NOT REMOVE
+  /// Nitro requires a parameterless initializer for JS bridging.
+  /// This is invoked automatically during hybrid module construction.
+  /// Internally we always use `init(property:)`
+  override init() {
+    super.init()
+  }
+  
+  var value: String {
+    get {
+      return property.value
+    }
+    set {
+      property.value = newValue
+    }
+  }
+}

package/ios/HybridViewModelTriggerProperty.swift

@@ -0,0 +1,30 @@
+import NitroModules
+import RiveRuntime
+
+class HybridViewModelTriggerProperty: HybridViewModelTriggerPropertySpec, ValuedPropertyProtocol {
+  internal var property: TriggerPropertyType!
+  lazy var helper = PropertyListenerHelper(property: property!)
+
+  private var listenerIds: [UUID] = []
+
+  func addListener(onChanged: @escaping () -> Void) throws {
+    try addListener(onChanged: { _ in onChanged() })
+  }
+
+  init(property: TriggerPropertyType) {
+    self.property = property
+    super.init()
+  }
+  
+  /// ⚠️ DO NOT REMOVE
+  /// Nitro requires a parameterless initializer for JS bridging.
+  /// This is invoked automatically during hybrid module construction.
+  /// Internally we always use `init(property:)`
+  override init() {
+    super.init()
+  }
+  
+  func trigger() {
+    property.trigger()
+  }
+}

package/ios/RCTLog.swift

@@ -0,0 +1,29 @@
+func RCTLogError(_ message: String, _ file: String=#file, _ line: UInt=#line) {
+    DispatchQueue.main.async {
+        RCTSwiftLog.error(message, file: file, line: line)
+    }
+}
+
+func RCTLogWarn(_ message: String, _ file: String=#file, _ line: UInt=#line) {
+    DispatchQueue.main.async {
+        RCTSwiftLog.warn(message, file: file, line: line)
+    }
+}
+
+func RCTLogInfo(_ message: String, _ file: String=#file, _ line: UInt=#line) {
+    DispatchQueue.main.async {
+        RCTSwiftLog.info(message, file: file, line: line)
+    }
+}
+
+func RCTLog(_ message: String, _ file: String=#file, _ line: UInt=#line) {
+    DispatchQueue.main.async {
+        RCTSwiftLog.log(message, file: file, line: line)
+    }
+}
+
+func RCTLogTrace(_ message: String, _ file: String=#file, _ line: UInt=#line) {
+    DispatchQueue.main.async {
+        RCTSwiftLog.trace(message, file: file, line: line)
+    }
+}

package/ios/RCTSwiftLog.h

@@ -0,0 +1,11 @@
+#import <Foundation/Foundation.h>
+
+@interface RCTSwiftLog : NSObject
+
++ (void)error:(NSString * _Nonnull)message file:(NSString * _Nonnull)file line:(NSUInteger)line;
++ (void)warn:(NSString * _Nonnull)message file:(NSString * _Nonnull)file line:(NSUInteger)line;
++ (void)info:(NSString * _Nonnull)message file:(NSString * _Nonnull)file line:(NSUInteger)line;
++ (void)log:(NSString * _Nonnull)message file:(NSString * _Nonnull)file line:(NSUInteger)line;
++ (void)trace:(NSString * _Nonnull)message file:(NSString * _Nonnull)file line:(NSUInteger)line;
+
+@end