react-nitro-renderer 0.0.0-stage → 0.0.1-alpha.7

package/Sources/ReactNitroRenderer/Components/View.swift

@@ -0,0 +1,267 @@
+//
+//  View.swift
+//  ReactNitroRenderer
+//
+//  Created by Marc Rousavy on 18.09.26.
+//
+
+public import UIKit
+internal import NitroModules
+internal import yoga
+
+public protocol View: AnyObject {
+  associatedtype ViewType: UIView
+  associatedtype AllowedChildrenType
+  var view: ViewType { get }
+  var yogaNode: YGNode { get }
+  var parentReference: (any HybridViewSpec)? { get set }
+  var yogaNodePtr: Double { get }
+  var cornerCurve: CornerCurve { get set }
+}
+
+public extension View {
+  var safeAreaInsets: EdgeInsets {
+    let insets = view.safeAreaInsets
+    return EdgeInsets(insets)
+  }
+
+  var parent: (any HybridViewSpec)? {
+    return parentReference
+  }
+
+  var yogaNodePtr: Double {
+    let address = UInt(bitPattern: yogaNode.ref)
+    let bits = UInt64(address)
+    return Double(bitPattern: bits)
+  }
+  
+  //MARK: Props
+  
+  var backgroundColor: Double? {
+    guard let color = view.backgroundColor else {
+      return nil
+    }
+    let resolved = color.resolvedColor(with: view.traitCollection)
+    guard let rgba = resolved.rgba else {
+      return nil
+    }
+    return Double(rgba)
+  }
+
+  func setBackgroundColor(color: Double) throws {
+    guard let rgba = UInt32(exactly: color) else {
+      throw RuntimeError("Invalid background color \(color): expected an integer between 0 and 0xffffffff in 0xRRGGBBAA format.")
+    }
+    view.backgroundColor = UIColor(rgba: rgba)
+  }
+
+  var opacity: Double {
+    get {
+      return view.alpha
+    }
+    set {
+      view.alpha = newValue
+    }
+  }
+  
+  var borderWidth: Double? {
+    get {
+      return view.layer.borderWidth
+    }
+    set {
+      view.layer.borderWidth = newValue ?? 0
+    }
+  }
+  
+  var borderColor: Double? {
+    guard let color = view.layer.borderColor else {
+      return nil
+    }
+    let uiColor = UIColor(cgColor: color)
+    guard let rgba = uiColor.rgba else {
+      return nil
+    }
+    return Double(rgba)
+  }
+  
+  func setBorderColor(color: Double?) throws {
+    guard let color else {
+      view.layer.borderColor = nil
+      return;
+    }
+    
+    guard let rgba = UInt32(exactly: color) else {
+      throw RuntimeError("Invalid background color \(color): expected an integer between 0 and 0xffffffff in 0xRRGGBBAA format.")
+    }
+    view.layer.borderColor = UIColor(rgba: rgba).cgColor
+  }
+  
+  var cornerRadius: Double {
+    get {
+      return view.layer.cornerRadius
+    }
+    set {
+      view.layer.cornerRadius = newValue
+    }
+  }
+
+  var maskedCorners: [Corner] {
+    get {
+      let mask = view.layer.maskedCorners
+      let corners: [Corner] = [.topleft, .topright, .bottomleft, .bottomright]
+      return corners.filter { corner in
+        let cornerMask = corner.toCACornerMask()
+        return mask.contains(cornerMask)
+      }
+    }
+    set {
+      var mask: CACornerMask = []
+      for corner in newValue {
+        let cornerMask = corner.toCACornerMask()
+        mask.formUnion(cornerMask)
+      }
+      view.layer.maskedCorners = mask
+    }
+  }
+
+  var cornerCurve: CornerCurve {
+    get {
+      let curve = view.layer.cornerCurve
+      return CornerCurve(curve)
+    }
+    set {
+      let curve = newValue.toUICornerCurve()
+      view.layer.cornerCurve = curve
+    }
+  }
+
+  var translation: Point3D {
+    let transform = view.layer.transform
+    let x = Double(transform.m41)
+    let y = Double(transform.m42)
+    let z = Double(transform.m43)
+    return Point3D(x: x, y: y, z: z)
+  }
+
+  func setTranslation(x: Double, y: Double, z: Double) throws {
+    guard x.isFinite && y.isFinite && z.isFinite else {
+      throw RuntimeError("Invalid translation (\(x), \(y), \(z)): expected finite numbers.")
+    }
+    var transform = view.layer.transform
+    transform.m41 = CGFloat(x)
+    transform.m42 = CGFloat(y)
+    transform.m43 = CGFloat(z)
+    let isUnchanged = CATransform3DEqualToTransform(view.layer.transform, transform)
+    if isUnchanged {
+      return
+    }
+    view.layer.transform = transform
+  }
+
+  var scale: Point3D {
+    let transform = view.layer.transform
+    let x = Double(transform.m11)
+    let y = Double(transform.m22)
+    let z = Double(transform.m33)
+    return Point3D(x: x, y: y, z: z)
+  }
+
+  func setScale(x: Double, y: Double, z: Double) throws {
+    guard x.isFinite && y.isFinite && z.isFinite else {
+      throw RuntimeError("Invalid scale (\(x), \(y), \(z)): expected finite numbers.")
+    }
+    // TODO: Remove zero substitution once UIKit fixes zero-scale transform interpolation on all supported iOS versions.
+    // Reports: https://stackoverflow.com/questions/25964224/cgaffinetransformscale-not-working-with-zero-scale
+    // https://stackoverflow.com/questions/75793513/uiview-animation-downscale-instantly-hides-the-view
+    let zeroScaleReplacement = 0.00001
+    var transform = view.layer.transform
+    transform.m11 = CGFloat(x == 0 ? zeroScaleReplacement : x)
+    transform.m22 = CGFloat(y == 0 ? zeroScaleReplacement : y)
+    transform.m33 = CGFloat(z == 0 ? zeroScaleReplacement : z)
+    let isUnchanged = CATransform3DEqualToTransform(view.layer.transform, transform)
+    if isUnchanged {
+      return
+    }
+    view.layer.transform = transform
+  }
+
+  func getFrame() -> Frame {
+    let size = view.bounds.size
+    let center = view.center
+    return Frame(x: center.x - size.width / 2,
+                 y: center.y - size.height / 2,
+                 width: size.width,
+                 height: size.height)
+  }
+
+  func setFrame(frame: Frame) throws {
+    view.bounds.size = CGSize(width: frame.width, height: frame.height)
+    view.center = CGPoint(x: frame.x + frame.width / 2,
+                          y: frame.y + frame.height / 2)
+  }
+
+  func afterUpdate() {
+    let isYogaNodeDirty = YGNodeIsDirty(yogaNode.ref)
+    if isYogaNodeDirty {
+      let overflow = YGNodeStyleGetOverflow(yogaNode.ref)
+      view.clipsToBounds = overflow == .hidden
+    }
+  }
+
+  //MARK: Gestures
+
+  func setGestureRecognizers(gestureRecognizers: [any HybridGestureRecognizerSpec]?) throws {
+    view.gestureRecognizers?.forEach { prevGestureRecognizer in
+      view.removeGestureRecognizer(prevGestureRecognizer)
+    }
+    gestureRecognizers?.forEach { newGestureRecognizer in
+      view.addGestureRecognizer(newGestureRecognizer.gestureRecognizer)
+    }
+  }
+
+  var isUserInteractionEnabled: Bool {
+    get {
+      return view.isUserInteractionEnabled
+    }
+    set {
+      view.isUserInteractionEnabled = newValue
+    }
+  }
+}
+
+public extension View where Self: HybridViewSpec {
+  //MARK: Child mutations
+
+  func appendChild(child: any HybridViewSpec) throws {
+    let childView = try getAllowedChildView(child: child)
+    view.addSubview(childView)
+    child.parentReference = self
+  }
+  
+  func insertBefore(child: any HybridViewSpec, beforeChild: any HybridViewSpec) throws {
+    let childView = try getAllowedChildView(child: child)
+    let beforeChildView = try getAllowedChildView(child: beforeChild)
+    if child === beforeChild {
+      return
+    }
+    view.insertSubview(childView, belowSubview: beforeChildView)
+    child.parentReference = self
+  }
+  
+  func removeChild(child: any HybridViewSpec) throws {
+    let childView = try getAllowedChildView(child: child)
+    childView.removeFromSuperview()
+    child.parentReference = nil
+  }
+
+  private func getAllowedChildView(child: any HybridViewSpec) throws -> UIView {
+    if AllowedChildrenType.self == Never.self {
+      throw RuntimeError("\(Self.self) does not support children!")
+    }
+    guard child is AllowedChildrenType else {
+      let expectedType = String(describing: AllowedChildrenType.self)
+      throw RuntimeError("Unsupported child View type for \(Self.self). Expected \(expectedType).")
+    }
+    return child.view
+  }
+}

package/Sources/ReactNitroRenderer/CustomViewController.swift

@@ -0,0 +1,36 @@
+internal import NitroModules
+internal import UIKit
+
+final class CustomViewController: UIViewController {
+  private var onKeyPressedListeners: [UIKeyCommand: () -> Void] = [:]
+  private let safeAreaInsetsListeners = SafeAreaInsetsListeners()
+
+  override func viewSafeAreaInsetsDidChange() {
+    super.viewSafeAreaInsetsDidChange()
+    let insets = view.safeAreaInsets
+    let edgeInsets = EdgeInsets(insets)
+    safeAreaInsetsListeners.emit(edgeInsets)
+  }
+
+  func addOnSafeAreaInsetsChangedListener(_ listener: @escaping (EdgeInsets) -> Void) -> ListenerSubscription {
+    return safeAreaInsetsListeners.add(listener)
+  }
+
+  func addOnKeyPressedListener(key: String, modifiers: [ModifierKey], onPress: @escaping () -> Void) -> ListenerSubscription {
+    let modifierFlags = modifiers.toUIKeyModifierFlags()
+    let command = UIKeyCommand(input: key,
+                              modifierFlags: modifierFlags,
+                              action: #selector(handleKeyCommand(_:)))
+    onKeyPressedListeners[command] = onPress
+    addKeyCommand(command)
+    return ListenerSubscription(remove: .native {
+      self.removeKeyCommand(command)
+      self.onKeyPressedListeners.removeValue(forKey: command)
+    })
+  }
+
+  @objc private func handleKeyCommand(_ command: UIKeyCommand) {
+    guard let listener = onKeyPressedListeners[command] else { return }
+    listener()
+  }
+}

package/Sources/ReactNitroRenderer/Extensions/Corner+toCACornerMask.swift

@@ -0,0 +1,16 @@
+internal import UIKit
+
+extension Corner {
+  func toCACornerMask() -> CACornerMask {
+    switch self {
+    case .topleft:
+      return .layerMinXMinYCorner
+    case .topright:
+      return .layerMaxXMinYCorner
+    case .bottomleft:
+      return .layerMinXMaxYCorner
+    case .bottomright:
+      return .layerMaxXMaxYCorner
+    }
+  }
+}

package/Sources/ReactNitroRenderer/Extensions/CornerCurve+toUICornerCurve.swift

@@ -0,0 +1,23 @@
+internal import UIKit
+
+extension CornerCurve {
+  init(_ uiCornerCurve: CALayerCornerCurve) {
+    switch uiCornerCurve {
+    case .circular:
+      self = .circular
+    case .continuous:
+      self = .continuous
+    default:
+      preconditionFailure("Unknown corner curve: \(uiCornerCurve.rawValue)")
+    }
+  }
+
+  func toUICornerCurve() -> CALayerCornerCurve {
+    switch self {
+    case .circular:
+      return .circular
+    case .continuous:
+      return .continuous
+    }
+  }
+}

package/Sources/ReactNitroRenderer/Extensions/EdgeInsets+UIEdgeInsets.swift

@@ -0,0 +1,7 @@
+internal import UIKit
+
+extension EdgeInsets {
+  init(_ insets: UIEdgeInsets) {
+    self.init(top: insets.top, right: insets.right, bottom: insets.bottom, left: insets.left)
+  }
+}

package/Sources/ReactNitroRenderer/Extensions/ModifierKey+toUIKeyModifierFlags.swift

@@ -0,0 +1,31 @@
+//
+//  ModifierKey+toUIKeyModifierFlags.swift
+//  ReactNitroRenderer
+//
+//  Created by Marc Rousavy on 18.09.26.
+//
+
+internal import UIKit
+
+extension ModifierKey {
+  func toUIKeyModifierFlags() -> UIKeyModifierFlags {
+    switch self {
+    case .command:
+      return .command
+    case .alternate:
+      return .alternate
+    case .control:
+      return .control
+    case .shift:
+      return .shift
+    }
+  }
+}
+
+extension [ModifierKey] {
+  func toUIKeyModifierFlags() -> UIKeyModifierFlags {
+    return reduce(into: UIKeyModifierFlags()) { flags, modifier in
+      flags.formUnion(modifier.toUIKeyModifierFlags())
+    }
+  }
+}

package/Sources/ReactNitroRenderer/Extensions/Point+CGPoint.swift

@@ -0,0 +1,15 @@
+internal import CoreGraphics
+
+extension Point {
+  init(_ point: CGPoint) {
+    let x = Double(point.x)
+    let y = Double(point.y)
+    self.init(x: x, y: y)
+  }
+
+  var cgPoint: CGPoint {
+    let x = CGFloat(self.x)
+    let y = CGFloat(self.y)
+    return CGPoint(x: x, y: y)
+  }
+}

package/Sources/ReactNitroRenderer/Extensions/UIGestureRecognizerState+toUIGestureRecognizerState.swift

@@ -0,0 +1,39 @@
+internal import UIKit
+
+extension GestureRecognizerState {
+  init(_ uiGestureRecognizerState: UIGestureRecognizer.State) {
+    switch uiGestureRecognizerState {
+    case .possible:
+      self = .possible
+    case .began:
+      self = .began
+    case .changed:
+      self = .changed
+    case .ended:
+      self = .ended
+    case .cancelled:
+      self = .cancelled
+    case .failed:
+      self = .failed
+    @unknown default:
+      preconditionFailure("Unknown gesture recognizer state: \(uiGestureRecognizerState.rawValue)")
+    }
+  }
+
+  func toUIGestureRecognizerState() -> UIGestureRecognizer.State {
+    switch self {
+    case .possible:
+      return .possible
+    case .began:
+      return .began
+    case .changed:
+      return .changed
+    case .ended:
+      return .ended
+    case .cancelled:
+      return .cancelled
+    case .failed:
+      return .failed
+    }
+  }
+}

package/Sources/ReactNitroRenderer/Gestures/HybridGestureRecognizer.swift

@@ -0,0 +1,40 @@
+//
+//  HybridGestureRecognizer.swift
+//  ReactNitroRenderer
+//
+//  Created by Hanno Gödecke on 19.10.2026.
+//
+
+public import UIKit
+
+public protocol HybridGestureRecognizer: AnyObject {
+  associatedtype Recognizer: UIGestureRecognizer
+  var gestureRecognizer: Recognizer { get }
+  
+  var numberOfTouches: Double { get }
+  var isEnabled: Bool { get set }
+  var state: GestureRecognizerState { get }
+}
+
+extension HybridGestureRecognizer {
+  var numberOfTouches: Double {
+    get {
+      return Double(gestureRecognizer.numberOfTouches)
+    }
+  }
+  
+  var isEnabled: Bool {
+    get {
+      return gestureRecognizer.isEnabled
+    }
+    set {
+      gestureRecognizer.isEnabled = newValue
+    }
+  }
+  
+  var state: GestureRecognizerState {
+    get {
+      return GestureRecognizerState(gestureRecognizer.state)
+    }
+  }
+}

package/Sources/ReactNitroRenderer/Gestures/HybridLongPressGestureRecognizer.swift

@@ -0,0 +1,53 @@
+internal import NitroModules
+internal import UIKit
+
+final class HybridLongPressGestureRecognizer: HybridLongPressGestureRecognizerSpec, HybridGestureRecognizer {
+  var gestureRecognizer: UILongPressGestureRecognizer = UILongPressGestureRecognizer()
+  var onLongPress: any Callback<any HybridLongPressGestureRecognizerSpec, Void>?
+
+  override init() throws {
+    try super.init()
+    let action = #selector(handleLongPress(_:))
+    self.gestureRecognizer.addTarget(self, action: action)
+  }
+
+  var minimumPressDuration: Double {
+    get {
+      return gestureRecognizer.minimumPressDuration
+    }
+    set {
+      gestureRecognizer.minimumPressDuration = newValue
+    }
+  }
+
+  var allowableMovement: Double {
+    get {
+      return Double(gestureRecognizer.allowableMovement)
+    }
+    set {
+      gestureRecognizer.allowableMovement = CGFloat(newValue)
+    }
+  }
+
+  var numberOfTapsRequired: Double {
+    get {
+      return Double(gestureRecognizer.numberOfTapsRequired)
+    }
+    set {
+      gestureRecognizer.numberOfTapsRequired = Int(newValue)
+    }
+  }
+
+  var numberOfTouchesRequired: Double {
+    get {
+      return Double(gestureRecognizer.numberOfTouchesRequired)
+    }
+    set {
+      gestureRecognizer.numberOfTouchesRequired = Int(newValue)
+    }
+  }
+
+  @objc private func handleLongPress(_ recognizer: UILongPressGestureRecognizer) throws {
+    try self.onLongPress?.callSync(self)
+  }
+}

package/Sources/ReactNitroRenderer/Gestures/HybridPanGestureRecognizer.swift

@@ -0,0 +1,52 @@
+//
+//  HybridPanGestureRecognizer.swift
+//  ReactNitroRenderer
+//
+//  Created by Hanno Gödecke on 20.10.2026.
+//
+
+internal import NitroModules
+internal import UIKit
+
+final class HybridPanGestureRecognizer : HybridPanGestureRecognizerSpec, HybridGestureRecognizer {
+  var gestureRecognizer: UIPanGestureRecognizer = UIPanGestureRecognizer()
+  var onPan: any Callback<any HybridPanGestureRecognizerSpec, Void>?
+  
+  override init() throws {
+    try super.init()
+    let action = #selector(handlePan(_:))
+    self.gestureRecognizer.addTarget(self, action: action)
+  }
+
+  var maximumNumberOfTouches: Double {
+    get {
+      return Double(gestureRecognizer.maximumNumberOfTouches)
+    }
+    set {
+      gestureRecognizer.maximumNumberOfTouches = Int(newValue)
+    }
+  }
+
+  var minimumNumberOfTouches: Double {
+    get {
+      return Double(gestureRecognizer.minimumNumberOfTouches)
+    }
+    set {
+      gestureRecognizer.minimumNumberOfTouches = Int(newValue)
+    }
+  }
+
+  func translation(inParent: any HybridViewSpec) throws -> Point {
+    let translation = gestureRecognizer.translation(in: inParent.view)
+    return Point(translation)
+  }
+
+  func velocity(inParent: any HybridViewSpec) throws -> Point {
+    let velocity = gestureRecognizer.velocity(in: inParent.view)
+    return Point(velocity)
+  }
+  
+  @objc private func handlePan(_ recognizer: UITapGestureRecognizer) throws {
+    try self.onPan?.callSync(self)
+  }
+}

package/Sources/ReactNitroRenderer/Gestures/HybridTapGestureRecognizer.swift

@@ -0,0 +1,42 @@
+//
+//  HybridTapGestureRecorgnizer.swift
+//  ReactNitroRenderer
+//
+//  Created by Hanno Gödecke on 19.10.2026.
+//
+
+internal import NitroModules
+internal import UIKit
+
+final class HybridTapGestureRecognizer : HybridTapGestureRecognizerSpec, HybridGestureRecognizer {
+  var gestureRecognizer: UITapGestureRecognizer = UITapGestureRecognizer()
+  var onTap: any Callback<any HybridTapGestureRecognizerSpec, Void>?
+  
+  override init() throws {
+    try super.init()
+    let action = #selector(handleTap(_:))
+    self.gestureRecognizer.addTarget(self, action: action)
+  }
+  
+  var numberOfTapsRequired: Double {
+    get {
+      return Double(gestureRecognizer.numberOfTapsRequired)
+    }
+    set {
+      gestureRecognizer.numberOfTapsRequired = Int(newValue)
+    }
+  }
+  
+  var numberOfTouchesRequired: Double {
+    get {
+      return Double(gestureRecognizer.numberOfTouchesRequired)
+    }
+    set {
+      gestureRecognizer.numberOfTouchesRequired = Int(newValue)
+    }
+  }
+  
+  @objc private func handleTap(_ recognizer: UITapGestureRecognizer) throws {
+    try self.onTap?.callSync(self)
+  }
+}

package/Sources/ReactNitroRenderer/HybridApplication.swift

@@ -0,0 +1,19 @@
+internal import NitroModules
+internal import UIKit
+
+final class HybridApplication: HybridApplicationSpec {
+  static func createView() throws -> any HybridViewSpec {
+    return try HybridView()
+  }
+
+  static func registerRoot(onSceneCreated: any Callback<any HybridWindowSceneSpec, any HybridWindowSpec>) throws {
+    try RegisterRootCallback.registerRoot(onSceneCreated: onSceneCreated)
+  }
+  
+  static func reloadRuntime() throws {
+    guard let reloadableRuntime = UIApplication.shared.delegate as? any RuntimeReloadableAppDelegate else {
+      throw RuntimeError("Failed to reload Runtime - The main `AppDelegate` does not implement `RuntimeReloadableAppDelegate`!")
+    }
+    reloadableRuntime.reloadRuntime()
+  }
+}

package/Sources/ReactNitroRenderer/HybridScreen.swift

@@ -0,0 +1,22 @@
+internal import NitroModules
+internal import UIKit
+
+final class HybridScreen: HybridScreenSpec {
+  private let screen: UIScreen
+
+  var size: Size {
+    return Size(width: screen.bounds.width, height: screen.bounds.height)
+  }
+  var displayScale: Double {
+    return screen.scale
+  }
+  var brightness: Double {
+    return screen.brightness
+  }
+  
+  init(screen: UIScreen) {
+    self.screen = screen
+    // The generated base initializer is empty. Wrapping this UIKit object cannot fail.
+    try! super.init()
+  }
+}