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

package/Sources/ReactNitroRenderer/HybridViewController.swift

@@ -0,0 +1,66 @@
+internal import Foundation
+public import NitroModules
+internal import NitroModulesCxx
+public import UIKit
+
+public final class HybridViewController: HybridViewControllerSpec {
+  private let controller = CustomViewController()
+
+  public var viewController: UIViewController {
+    return controller
+  }
+
+  public override init() throws {
+    try super.init()
+  }
+
+  // Created on first access so `viewController.view` isn't loaded at init.
+  // Every read must return the same wrapper so its Yoga node keeps its children.
+  private lazy var rootView = HybridView(view: viewController.view)
+
+  public var view: any HybridViewSpec {
+    return rootView
+  }
+
+  public func addOnSafeAreaInsetsChangedListener(listener: any Callback<EdgeInsets, Void>) throws -> ListenerSubscription {
+    return controller.addOnSafeAreaInsetsChangedListener { insets in
+      do {
+        try listener.callSync(insets)
+      } catch {
+        margelo.nitro.GlobalErrorHandler.reportError(.UICallback, error.toCpp())
+      }
+    }
+  }
+  
+  public func present(other: any HybridViewControllerSpec, animated: Bool, completion: any Callback<(), Void>) throws {
+    self.viewController.present(other.viewController,
+                                animated: animated) {
+      do {
+        try completion.callSync()
+      } catch {
+        margelo.nitro.GlobalErrorHandler.reportError(.UICallback, error.toCpp())
+      }
+    }
+  }
+  
+  public func dismiss(animated: Bool, completion: any Callback<(), Void>) throws {
+    self.viewController.dismiss(animated: animated) {
+      do {
+        try completion.callSync()
+      } catch {
+        margelo.nitro.GlobalErrorHandler.reportError(.UICallback, error.toCpp())
+      }
+    }
+  }
+  
+  public func addOnKeyPressedListener(key: String, modifiers: [ModifierKey], onPress: any Callback<(), Void>) throws -> ListenerSubscription {
+    controller.addOnKeyPressedListener(key: key,
+                                                modifiers: modifiers) {
+      do {
+        try onPress.callSync()
+      } catch {
+        margelo.nitro.GlobalErrorHandler.reportError(.UICallback, error.toCpp())
+      }
+    }
+  }
+}

package/Sources/ReactNitroRenderer/HybridWindow.swift

@@ -0,0 +1,25 @@
+internal import NitroModules
+internal import UIKit
+
+final class HybridWindow: HybridWindowSpec {
+  let window: UIWindow
+  var screen: any HybridScreenSpec {
+    return HybridScreen(screen: window.screen)
+  }
+  
+  init(window: UIWindow) {
+    self.window = window
+    // The generated base initializer is empty. Wrapping this UIKit object cannot fail.
+    try! super.init()
+  }
+  
+  convenience init(scene: any HybridWindowSceneSpec, rootViewController: any HybridViewControllerSpec) throws {
+    let window = UIWindow(windowScene: scene.scene)
+    window.rootViewController = rootViewController.viewController
+    self.init(window: window)
+  }
+  
+  func makeKeyAndVisible() throws {
+    window.makeKeyAndVisible()
+  }
+}

package/Sources/ReactNitroRenderer/HybridWindowScene.swift

@@ -0,0 +1,16 @@
+internal import NitroModules
+internal import UIKit
+
+final class HybridWindowScene: HybridWindowSceneSpec {
+  let scene: UIWindowScene
+  
+  var windows: [any HybridWindowSpec] {
+    return scene.windows.map { HybridWindow(window: $0) }
+  }
+  
+  init(scene: UIWindowScene) {
+    self.scene = scene
+    // The generated base initializer is empty. Wrapping this UIKit object cannot fail.
+    try! super.init()
+  }
+}

package/Sources/ReactNitroRenderer/RegisterRootCallback.swift

@@ -0,0 +1,28 @@
+//
+//  RegisterRootCallback.swift
+//  ReactNitroRenderer
+//
+//  Created by Marc Rousavy on 18.09.26.
+//
+
+internal import NitroModules
+public import UIKit
+
+// TODO: Do we want to put this into something like AppDelegate or SceneDelegate instead? Like "ReactHost" or whatever?
+public struct RegisterRootCallback {
+  // TODO: This is kinda ugly because we pull in that callback later in `SceneDelegate`, statically...
+  private static var onSceneCreated: (any Callback<any HybridWindowSceneSpec, any HybridWindowSpec>)? = nil
+  
+  internal static func registerRoot(onSceneCreated: any Callback<any HybridWindowSceneSpec, any HybridWindowSpec>) throws {
+    Self.onSceneCreated = onSceneCreated
+  }
+  
+  public static func onSceneCreated(_ scene: UIWindowScene) throws -> UIWindow {
+    guard let onSceneCreated = Self.onSceneCreated else {
+      throw RuntimeError("No `onSceneCreated` listener was installed - was `registerRoot(..)` called?")
+    }
+    let hybridWindowScene = HybridWindowScene(scene: scene)
+    let hybridWindow = try onSceneCreated.callSync(hybridWindowScene)
+    return hybridWindow.window
+  }
+}

package/Sources/ReactNitroRenderer/RuntimeReloadableAppDelegate.swift

@@ -0,0 +1,14 @@
+//
+//  RuntimeReloadableAppDelegate.swift
+//  ReactNitroRenderer
+//
+//  Created by Marc Rousavy on 28.09.26.
+//
+
+/**
+ * Conform `AppDelegate` to `RuntimeReloadableAppDelegate` so
+ * `Application.reloadRuntime()` can reload the JS Runtime.
+ */
+public protocol RuntimeReloadableAppDelegate {
+  func reloadRuntime()
+}

package/Sources/ReactNitroRenderer/SafeAreaInsetsListeners.swift

@@ -0,0 +1,22 @@
+internal import Foundation
+internal import NitroModules
+
+// Accessed only on the main thread by UIKit and the JS runtime.
+final class SafeAreaInsetsListeners {
+  private var listeners: [UUID: (EdgeInsets) -> Void] = [:]
+
+  func add(_ listener: @escaping (EdgeInsets) -> Void) -> ListenerSubscription {
+    let id = UUID()
+    listeners[id] = listener
+    return ListenerSubscription(remove: .native { [weak self] in
+      self?.listeners.removeValue(forKey: id)
+    })
+  }
+
+  func emit(_ insets: EdgeInsets) {
+    let currentListeners = Array(listeners.values)
+    for listener in currentListeners {
+      listener(insets)
+    }
+  }
+}

package/Sources/ReactNitroRenderer/UIColor+initRGBA.swift

@@ -0,0 +1,10 @@
+internal import UIKit
+
+extension UIColor {
+  convenience init(rgba: UInt32) {
+    self.init(red: CGFloat((rgba >> 24) & 0xff) / 255,
+              green: CGFloat((rgba >> 16) & 0xff) / 255,
+              blue: CGFloat((rgba >> 8) & 0xff) / 255,
+              alpha: CGFloat(rgba & 0xff) / 255)
+  }
+}

package/Sources/ReactNitroRenderer/UIColor+rgba.swift

@@ -0,0 +1,20 @@
+internal import UIKit
+
+extension UIColor {
+  /// The color packed as 0xRRGGBBAA, or nil if it cannot be converted to RGB.
+  var rgba: UInt32? {
+    var red: CGFloat = 0
+    var green: CGFloat = 0
+    var blue: CGFloat = 0
+    var alpha: CGFloat = 0
+    guard getRed(&red, green: &green, blue: &blue, alpha: &alpha),
+          red.isFinite, green.isFinite, blue.isFinite, alpha.isFinite else {
+      return nil
+    }
+
+    func byte(_ component: CGFloat) -> UInt32 {
+      return UInt32((min(1, max(0, component)) * 255).rounded())
+    }
+    return (byte(red) << 24) | (byte(green) << 16) | (byte(blue) << 8) | byte(alpha)
+  }
+}

package/Sources/ReactNitroRenderer/ViewController.swift

@@ -0,0 +1,13 @@
+//
+//  ViewController.swift
+//  ReactNitroRenderer
+//
+//  Created by Marc Rousavy on 18.09.26.
+//
+
+public import UIKit
+
+public protocol ViewController {
+  associatedtype ViewControllerType: UIViewController
+  var viewController: ViewControllerType { get }
+}

package/Sources/ReactNitroRenderer/Window.swift

@@ -0,0 +1,12 @@
+//
+//  Window.swift
+//  ReactNitroRenderer
+//
+//  Created by Marc Rousavy on 18.09.26.
+//
+
+public import UIKit
+
+public protocol Window {
+  var window: UIWindow { get }
+}

package/Sources/ReactNitroRenderer/WindowScene.swift

@@ -0,0 +1,12 @@
+//
+//  WindowScene.swift
+//  ReactNitroRenderer
+//
+//  Created by Marc Rousavy on 18.09.26.
+//
+
+public import UIKit
+
+public protocol WindowScene {
+  var scene: UIWindowScene { get }
+}

package/Sources/ReactNitroRenderer/YGNode.swift

@@ -0,0 +1,46 @@
+public import yoga
+
+public struct YGNode: ~Copyable {
+  typealias MeasureFunction = (Float, YGMeasureMode, Float, YGMeasureMode) -> YGSize
+
+  public let ref: YGNodeRef
+  private let measureContext: MeasureContext?
+
+  public init() {
+    ref = YGNodeNew()
+    measureContext = nil
+  }
+
+  init(measure: @escaping MeasureFunction) {
+    ref = YGNodeNew()
+    let context = MeasureContext(measure: measure)
+    measureContext = context
+
+    // The wrapper owns the context; Yoga only borrows its stable address.
+    let unmanagedContext = Unmanaged.passUnretained(context)
+    let contextPointer = unmanagedContext.toOpaque()
+    YGNodeSetContext(ref, contextPointer)
+    YGNodeSetMeasureFunc(ref) { nodeRef, width, widthMode, height, heightMode in
+      guard let nodeRef, let contextPointer = YGNodeGetContext(nodeRef) else {
+        fatalError("Yoga measure callback is missing its context.")
+      }
+      let unmanagedContext = Unmanaged<MeasureContext>.fromOpaque(contextPointer)
+      let context = unmanagedContext.takeUnretainedValue()
+      return context.measure(width, widthMode, height, heightMode)
+    }
+  }
+
+  deinit {
+    withExtendedLifetime(measureContext) {
+      YGNodeFree(ref)
+    }
+  }
+
+  private final class MeasureContext {
+    let measure: MeasureFunction
+
+    init(measure: @escaping MeasureFunction) {
+      self.measure = measure
+    }
+  }
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true