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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Margelo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Package.swift

@@ -0,0 +1,104 @@
+// swift-tools-version: 6.4
+
+import Foundation
+import PackageDescription
+
+let name = "ReactNitroNavigation"
+let generated = "nitrogen/generated"
+let nitroDependencies: [Target.Dependency] = [
+  .product(name: "NitroModules", package: "nitro-core"),
+  .product(name: "ReactNitroRenderer", package: "react-nitro-renderer"),
+]
+let cxxSettings: [CXXSetting] = [
+  .define("DEBUG", .when(configuration: .debug)),
+  .define("NDEBUG", .when(configuration: .release)),
+  .disableWarning("nullability-extension"),
+]
+let swiftSources = ["Sources/ReactNitroNavigation", "\(generated)/apple/swift"]
+let bridgeSources = [
+  "c++", "ReactNitroNavigation-Swift-Cxx-Bridge.cpp", "ReactNitroNavigationAutolinking.cpp",
+]
+
+// Bare-host integration. Nitrogen generates the bindings; this manifest owns the targets.
+let package = Package(
+  name: name,
+  platforms: [.iOS(.v16), .macOS(.v13)],
+  products: [
+    .library(name: name, targets: ["\(name)Cxx", name, "\(name)SwiftBridge"])
+  ],
+  dependencies: [
+    .package(path: "../nitro-core"),
+    .package(path: "../react-nitro-renderer"),
+  ],
+  targets: [
+    .target(
+      name: "\(name)Cxx",
+      dependencies: nitroDependencies,
+      path: "\(generated)/shared/c++",
+      exclude: ["include"],
+      publicHeadersPath: "include",
+      cxxSettings: cxxSettings
+    ),
+    .target(
+      name: "\(name)AppleCxx",
+      dependencies: [.target(name: "\(name)Cxx")] + nitroDependencies,
+      path: "\(generated)/apple/\(name)AppleCxx",
+      cxxSettings: cxxSettings
+    ),
+    .target(
+      name: name,
+      dependencies: [.target(name: "\(name)AppleCxx")] + nitroDependencies,
+      path: ".",
+      exclude: excludes(in: ".", keeping: swiftSources),
+      sources: swiftSources,
+      cxxSettings: cxxSettings,
+      swiftSettings: [
+        // UIKit implementations run synchronously on the host's main thread.
+        .swiftLanguageMode(.v5),
+        .unsafeFlags(["-strict-concurrency=minimal"]),
+        .enableUpcomingFeature("InternalImportsByDefault"),
+        .enableUpcomingFeature("MemberImportVisibility"),
+        .interoperabilityMode(.Cxx),
+        .unsafeFlags(["-Xfrontend", "-clang-header-expose-decls=has-expose-attr-or-stdlib"]),
+        .unsafeFlags([
+          "-Xfrontend", "-clang-header-expose-module",
+          "-Xfrontend", "NitroModules=NitroModules-Swift.h",
+        ]),
+      ]
+    ),
+    .target(
+      name: "\(name)SwiftBridge",
+      dependencies: [.target(name: name), .target(name: "\(name)AppleCxx")] + nitroDependencies,
+      path: "\(generated)/apple",
+      exclude: excludes(in: "\(generated)/apple", keeping: bridgeSources) + ["c++/include"],
+      sources: bridgeSources,
+      publicHeadersPath: "c++/include",
+      cxxSettings: cxxSettings + [
+        .unsafeFlags(["-I${GENERATED_MODULEMAP_DIR}", "-fno-modules"])
+      ]
+    ),
+  ],
+  cxxLanguageStandard: .cxx20
+)
+
+func excludes(in path: String, keeping sources: [String]) -> [String] {
+  var parents: Set<String> = [""]
+  for source in sources {
+    var components = source.split(separator: "/").dropLast()
+    while !components.isEmpty {
+      parents.insert(components.joined(separator: "/"))
+      components = components.dropLast()
+    }
+  }
+  let root = URL(fileURLWithPath: Context.packageDirectory).appendingPathComponent(path)
+  return parents.sorted().flatMap { parent in
+    let entries =
+      (try? FileManager.default.contentsOfDirectory(
+        atPath: root.appendingPathComponent(parent).path)) ?? []
+    return entries.sorted().compactMap { entry in
+      let entryPath = parent.isEmpty ? entry : "\(parent)/\(entry)"
+      return entry.hasPrefix(".") || sources.contains(entryPath) || parents.contains(entryPath)
+        ? nil : entryPath
+    }
+  }
+}

package/README.md

@@ -1,3 +1,21 @@
-# Temporary Holding Version
+# React Nitro Navigation spike
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Uses React Navigation Core and Routers with a Nitro bridge to UIKit's
+`UINavigationController`. The example app demonstrates Home → Animations → Spring.
+
+- `NavigationContainer` is the core's `BaseNavigationContainer`.
+- `createStackNavigator` supports the dynamic `Navigator` / `Screen` API and titles.
+- JS push/back actions update the native stack. Completed native back actions pop
+  the router; cancelled gestures leave its state unchanged.
+- Stack and screen host components stay in the normal React tree. The native stack
+  keeps its ordered screen children and gives their views to `UINavigationController`.
+- UIKit positions screen roots during transitions. Their Yoga nodes fill the stack
+  and lay out the screen contents. Each screen provides its controller's safe area.
+
+The native implementations, Nitro specs, generated bindings, and Swift package
+belong to this package. The renderer exposes generic host registration and
+controller construction; it has no navigation dependency.
+
+This is an iOS spike. Deep links, tabs, modals, removal prevention, transition
+events, and retaining removed screens during JS-driven pop animations are outside
+its scope.

package/Sources/ReactNitroNavigation/HybridNavigationScreen.swift

@@ -0,0 +1,27 @@
+internal import NitroModules
+internal import ReactNitroRenderer
+internal import UIKit
+
+final class HybridNavigationScreen: HybridNavigationScreenSpec {
+  typealias AllowedChildrenType = any View
+
+  let yogaNode = YGNode()
+  var parentReference: (any HybridViewSpec)?
+  let viewController: any HybridViewControllerSpec
+  var view: UIView { return viewController.viewController.view }
+
+  override init() throws {
+    viewController = try HybridViewController()
+    try super.init()
+    view.backgroundColor = .systemBackground
+  }
+
+  var title: String? {
+    get { return viewController.viewController.title }
+    set { viewController.viewController.title = newValue }
+  }
+
+  func setFrame(frame: Frame) throws {
+    // UIKit positions the screen root during transitions; Yoga only positions its children.
+  }
+}

package/Sources/ReactNitroNavigation/HybridNavigationStack.swift

@@ -0,0 +1,103 @@
+internal import Foundation
+internal import NitroModules
+internal import NitroModulesCxx
+internal import ReactNitroRenderer
+internal import UIKit
+
+final class HybridNavigationStack: HybridNavigationStackSpec {
+  typealias AllowedChildrenType = HybridNavigationScreen
+
+  let view = UIView()
+  let yogaNode = YGNode()
+  var parentReference: (any HybridViewSpec)?
+
+  private let navigationController = UINavigationController()
+  private let delegate = NavigationControllerDelegate()
+  private var screens: [HybridNavigationScreen] = []
+  private var expectedCount = 0
+  private var listeners: [UUID: any Callback<Double, Void>] = [:]
+
+  override init() throws {
+    try super.init()
+    navigationController.delegate = delegate
+    delegate.onDidShow = { [weak self] in self?.didShow() }
+  }
+
+  func attachTo(parent: any HybridViewControllerSpec) throws {
+    let parentController = parent.viewController
+    parentController.addChild(navigationController)
+    navigationController.view.frame = view.bounds
+    navigationController.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+    view.addSubview(navigationController.view)
+    navigationController.didMove(toParent: parentController)
+  }
+
+  func removeFromParent() throws {
+    navigationController.willMove(toParent: nil)
+    navigationController.view.removeFromSuperview()
+    navigationController.removeFromParent()
+  }
+
+  func appendChild(child: any HybridViewSpec) throws {
+    guard let screen = child as? HybridNavigationScreen else {
+      throw RuntimeError("A navigation stack only accepts navigation screens.")
+    }
+    screens.removeAll { $0 === screen }
+    screens.append(screen)
+    screen.parentReference = self
+    updateControllers()
+  }
+
+  func insertBefore(child: any HybridViewSpec, beforeChild: any HybridViewSpec) throws {
+    if child === beforeChild { return }
+    guard let screen = child as? HybridNavigationScreen else {
+      throw RuntimeError("A navigation stack only accepts navigation screens.")
+    }
+    screens.removeAll { $0 === screen }
+    guard let index = screens.firstIndex(where: { $0 === beforeChild }) else {
+      throw RuntimeError("The screen to insert before is not in this stack.")
+    }
+    screens.insert(screen, at: index)
+    screen.parentReference = self
+    updateControllers()
+  }
+
+  func removeChild(child: any HybridViewSpec) throws {
+    screens.removeAll { $0 === child }
+    child.parentReference = nil
+    updateControllers()
+  }
+
+  func addOnPopListener(listener: any Callback<Double, Void>) throws -> ListenerSubscription {
+    let id = UUID()
+    listeners[id] = listener
+    let remove: any Callback<(), Void> = .native { [weak self] in
+      self?.listeners.removeValue(forKey: id)
+    }
+    return ListenerSubscription(remove: remove)
+  }
+
+  private func updateControllers() {
+    let controllers = screens.map { $0.viewController.viewController }
+    expectedCount = controllers.count
+    let animated = navigationController.view.window != nil
+    navigationController.setViewControllers(controllers, animated: animated)
+  }
+
+  private func didShow() {
+    let count = navigationController.viewControllers.count
+    let removedCount = expectedCount - count
+    expectedCount = count
+    guard removedCount > 0 else { return }
+    let currentListeners = Array(listeners.values)
+    let removedCountValue = Double(removedCount)
+    for listener in currentListeners {
+      do {
+        try listener.callSync(removedCountValue)
+      } catch {
+        let nativeError = error.toCpp()
+        margelo.nitro.GlobalErrorHandler.reportError(.UICallback, nativeError)
+      }
+    }
+  }
+}

package/Sources/ReactNitroNavigation/NavigationControllerDelegate.swift

@@ -0,0 +1,11 @@
+internal import UIKit
+
+final class NavigationControllerDelegate: NSObject, UINavigationControllerDelegate {
+  var onDidShow: (() -> Void)?
+
+  func navigationController(_ navigationController: UINavigationController,
+                            didShow viewController: UIViewController,
+                            animated: Bool) {
+    onDidShow?()
+  }
+}

package/nitrogen/generated/.gitattributes

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

package/nitrogen/generated/apple/ReactNitroNavigation-Swift-Cxx-Bridge.cpp

@@ -0,0 +1,109 @@
+///
+/// ReactNitroNavigation-Swift-Cxx-Bridge.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+#include <ReactNitroNavigation/private/ReactNitroNavigation-Swift-Cxx-Umbrella.hpp>
+#include <ReactNitroRendererAppleCxx/ReactNitroRendererAppleCxx.h>
+#include <ReactNitroNavigation/private/HybridNavigationScreenSpecSwift.hpp>
+#include <ReactNitroNavigation/private/HybridNavigationStackSpecSwift.hpp>
+#include <NitroModules/Callback.hpp>
+
+namespace margelo::nitro::navigation::swift_bridge {
+  std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_(void* NON_NULL pointer) {
+    return margelo::nitro::renderer::swift_bridge::create_std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_(pointer);
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_(const std::shared_ptr<HybridObject>& value) {
+    return margelo::nitro::renderer::swift_bridge::get_std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_(value);
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_(void* NON_NULL pointer) {
+    return margelo::nitro::renderer::swift_bridge::create_std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_(pointer);
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_(const std::shared_ptr<HybridObject>& value) {
+    return margelo::nitro::renderer::swift_bridge::get_std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_(value);
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_(void* NON_NULL pointer) {
+    return margelo::nitro::renderer::swift_bridge::create_std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_(pointer);
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_(const std::shared_ptr<HybridObject>& value) {
+    return margelo::nitro::renderer::swift_bridge::get_std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_(value);
+  }
+
+  std__shared_ptr_margelo__nitro__navigation__HybridNavigationScreenSpec_ create_std__shared_ptr_margelo__nitro__navigation__HybridNavigationScreenSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::navigation::HybridNavigationScreenSpecSwift>(::ReactNitroNavigation::HybridNavigationScreenSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__navigation__HybridNavigationScreenSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::navigation::HybridNavigationScreenSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridNavigationScreenSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std::shared_ptr<margelo::nitro::renderer::HybridViewSpecSwift> upcast_NavigationScreen_to_View(const std__shared_ptr_margelo__nitro__navigation__HybridNavigationScreenSpec_& value) {
+    return value;
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_(void* NON_NULL pointer) {
+    return margelo::nitro::renderer::swift_bridge::create_std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_(pointer);
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_(const std::shared_ptr<HybridObject>& value) {
+    return margelo::nitro::renderer::swift_bridge::get_std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_(value);
+  }
+
+  std__shared_ptr_margelo__nitro__navigation__HybridNavigationStackSpec_ create_std__shared_ptr_margelo__nitro__navigation__HybridNavigationStackSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::navigation::HybridNavigationStackSpecSwift>(::ReactNitroNavigation::HybridNavigationStackSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__navigation__HybridNavigationStackSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::navigation::HybridNavigationStackSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridNavigationStackSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std::shared_ptr<margelo::nitro::renderer::HybridViewSpecSwift> upcast_NavigationStack_to_View(const std__shared_ptr_margelo__nitro__navigation__HybridNavigationStackSpec_& value) {
+    return value;
+  }
+
+  Result<void, margelo::nitro::navigation::swift_bridge::ResultTag> callSync_Callback_void(const Callback_void& callback) noexcept {
+    try {
+      callback.callSync();
+      return Result<void, margelo::nitro::navigation::swift_bridge::ResultTag>::withValue();
+    } catch (...) {
+      return Result<void, margelo::nitro::navigation::swift_bridge::ResultTag>::withError(std::current_exception());
+    }
+  }
+
+  Callback_void create_Callback_void(std::function<Result<void, margelo::nitro::navigation::swift_bridge::ResultTag>()> closure) {
+    return Callback_void::make([closure = std::move(closure)]() -> void {
+      auto __result = closure();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    });
+  }
+
+  Result<void, margelo::nitro::navigation::swift_bridge::ResultTag> callSync_Callback_void_double(const Callback_void_double& callback, double param0) noexcept {
+    try {
+      callback.callSync(param0);
+      return Result<void, margelo::nitro::navigation::swift_bridge::ResultTag>::withValue();
+    } catch (...) {
+      return Result<void, margelo::nitro::navigation::swift_bridge::ResultTag>::withError(std::current_exception());
+    }
+  }
+
+  Callback_void_double create_Callback_void_double(std::function<Result<void, margelo::nitro::navigation::swift_bridge::ResultTag>(double param0)> closure) {
+    return Callback_void_double::make([closure = std::move(closure)](double param0) -> void {
+      auto __result = closure(param0);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    });
+  }
+} // namespace margelo::nitro::navigation::swift_bridge

package/nitrogen/generated/apple/ReactNitroNavigationAppleCxx/ReactNitroNavigationAppleCxx.cpp

@@ -0,0 +1,9 @@
+///
+/// ReactNitroNavigationAppleCxx.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+// Swift packages require at least one source file per C++ target.
+#include <ReactNitroNavigationAppleCxx/ReactNitroNavigationAppleCxx.h>

package/nitrogen/generated/apple/ReactNitroNavigationAppleCxx/include/ReactNitroNavigationAppleCxx/ReactNitroNavigationAppleCxx.h

@@ -0,0 +1,120 @@
+///
+/// ReactNitroNavigationAppleCxx.h
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+// Each Nitro module declares parts of the margelo::nitro namespace, and Swift
+// treats the namespace as owned by one of them. Re-export the modules this one
+// uses, so Swift files that import this module can name the namespace.
+#include <ReactNitroRendererAppleCxx/ReactNitroRendererAppleCxx.h>
+// Forward declaration of `HybridViewSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridViewSpec_cxx; }
+#ifndef SWIFT_SWIFT_H
+namespace swift { template <class T> class Optional; }
+#endif
+// Forward declaration of `EdgeInsets` to properly resolve imports.
+namespace ReactNitroRenderer { class EdgeInsets; }
+// Forward declaration of `Corner` to properly resolve imports.
+namespace ReactNitroRenderer { class Corner; }
+#ifndef SWIFT_SWIFT_H
+namespace swift { template <class T> class Array; }
+#endif
+// Forward declaration of `CornerCurve` to properly resolve imports.
+namespace ReactNitroRenderer { class CornerCurve; }
+// Forward declaration of `Point3D` to properly resolve imports.
+namespace ReactNitroRenderer { class Point3D; }
+// Forward declaration of `Frame` to properly resolve imports.
+namespace ReactNitroRenderer { class Frame; }
+// Forward declaration of `HybridAnimatorSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridAnimatorSpec_cxx; }
+// Forward declaration of `HybridGestureRecognizerSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridGestureRecognizerSpec_cxx; }
+// Forward declaration of `AnimationCurve` to properly resolve imports.
+namespace ReactNitroRenderer { class AnimationCurve; }
+#include <NitroModules/Callback.hpp>
+#include <NitroModules/Result.hpp>
+// Forward declaration of `HybridNavigationScreenSpec_cxx` to properly resolve imports.
+namespace ReactNitroNavigation { class HybridNavigationScreenSpec_cxx; }
+// Forward declaration of `HybridViewControllerSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridViewControllerSpec_cxx; }
+namespace swift { class String; }
+// Forward declaration of `HybridNavigationStackSpec_cxx` to properly resolve imports.
+namespace ReactNitroNavigation { class HybridNavigationStackSpec_cxx; }
+// Forward declaration of `ListenerSubscription` to properly resolve imports.
+namespace ReactNitroNavigation { class ListenerSubscription; }
+#include <NitroModules/HybridObject.hpp>
+// Forward declaration of `HybridViewSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridViewSpecSwift; }
+#include <NitroModules/NitroDefines.hpp>
+// Forward declaration of `HybridAnimatorSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridAnimatorSpecSwift; }
+// Forward declaration of `HybridGestureRecognizerSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridGestureRecognizerSpecSwift; }
+// Forward declaration of `HybridNavigationScreenSpecSwift` to properly resolve imports.
+namespace margelo::nitro::navigation { class HybridNavigationScreenSpecSwift; }
+// Forward declaration of `HybridViewControllerSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridViewControllerSpecSwift; }
+// Forward declaration of `HybridNavigationStackSpecSwift` to properly resolve imports.
+namespace margelo::nitro::navigation { class HybridNavigationStackSpecSwift; }
+#include <NitroModules/Promise.hpp>
+
+namespace margelo::nitro::navigation::swift_bridge {
+  using std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridViewSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridViewSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridViewSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridViewSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_(const std::shared_ptr<HybridObject>& value);
+  using std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridAnimatorSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridAnimatorSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridAnimatorSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridAnimatorSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_(const std::shared_ptr<HybridObject>& value);
+  using std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridGestureRecognizerSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridGestureRecognizerSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_(const std::shared_ptr<HybridObject>& value);
+  using std__shared_ptr_margelo__nitro__navigation__HybridNavigationScreenSpec_ = std::shared_ptr<margelo::nitro::navigation::HybridNavigationScreenSpecSwift>;
+  using std__weak_ptr_margelo__nitro__navigation__HybridNavigationScreenSpec_ = std::weak_ptr<margelo::nitro::navigation::HybridNavigationScreenSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__navigation__HybridNavigationScreenSpec_ weakify_std__shared_ptr_margelo__nitro__navigation__HybridNavigationScreenSpec_(const std__shared_ptr_margelo__nitro__navigation__HybridNavigationScreenSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__navigation__HybridNavigationScreenSpec_ create_std__shared_ptr_margelo__nitro__navigation__HybridNavigationScreenSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__navigation__HybridNavigationScreenSpec_(const std::shared_ptr<HybridObject>& value);
+  std::shared_ptr<margelo::nitro::renderer::HybridViewSpecSwift> upcast_NavigationScreen_to_View(const std__shared_ptr_margelo__nitro__navigation__HybridNavigationScreenSpec_& value);
+  using std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridViewControllerSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridViewControllerSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridViewControllerSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridViewControllerSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_(const std::shared_ptr<HybridObject>& value);
+  // Distinct specializations prevent duplicate Swift metadata across module headers.
+  struct ResultTag {};
+  using Result_void_ = Result<void*, margelo::nitro::navigation::swift_bridge::ResultTag>;
+  using std__shared_ptr_margelo__nitro__navigation__HybridNavigationStackSpec_ = std::shared_ptr<margelo::nitro::navigation::HybridNavigationStackSpecSwift>;
+  using std__weak_ptr_margelo__nitro__navigation__HybridNavigationStackSpec_ = std::weak_ptr<margelo::nitro::navigation::HybridNavigationStackSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__navigation__HybridNavigationStackSpec_ weakify_std__shared_ptr_margelo__nitro__navigation__HybridNavigationStackSpec_(const std__shared_ptr_margelo__nitro__navigation__HybridNavigationStackSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__navigation__HybridNavigationStackSpec_ create_std__shared_ptr_margelo__nitro__navigation__HybridNavigationStackSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__navigation__HybridNavigationStackSpec_(const std::shared_ptr<HybridObject>& value);
+  std::shared_ptr<margelo::nitro::renderer::HybridViewSpecSwift> upcast_NavigationStack_to_View(const std__shared_ptr_margelo__nitro__navigation__HybridNavigationStackSpec_& value);
+  using Promise_void = Promise<void>;
+  using Result_void = Result<void, margelo::nitro::navigation::swift_bridge::ResultTag>;
+  using Callback_void = Callback<void()>;
+  Result<void, margelo::nitro::navigation::swift_bridge::ResultTag> callSync_Callback_void(const Callback_void& callback) noexcept;
+  Callback_void create_Callback_void(std::function<Result<void, margelo::nitro::navigation::swift_bridge::ResultTag>()> closure);
+  using Callback_void_double = Callback<void(double)>;
+  Result<void, margelo::nitro::navigation::swift_bridge::ResultTag> callSync_Callback_void_double(const Callback_void_double& callback, double param0) noexcept;
+  Callback_void_double create_Callback_void_double(std::function<Result<void, margelo::nitro::navigation::swift_bridge::ResultTag>(double param0)> closure);
+} // namespace margelo::nitro::navigation::swift_bridge

package/nitrogen/generated/apple/ReactNitroNavigationAutolinking.cpp

@@ -0,0 +1,22 @@
+///
+/// ReactNitroNavigationAutolinking.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroNavigation/ReactNitroNavigationAutolinking.hpp>
+#include <NitroModules/HybridClassRegistry.hpp>
+
+#include <ReactNitroNavigation/private/HybridNavigationScreenSpecSwift.hpp>
+#include <ReactNitroNavigation/private/HybridNavigationStackSpecSwift.hpp>
+
+namespace margelo::nitro::navigation {
+  void registerHybridClasses() {
+    using namespace margelo::nitro;
+    using namespace margelo::nitro::navigation;
+
+    HybridClassRegistry::registerHybridClass("navigation.NavigationScreen", HybridNavigationScreenSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("navigation.NavigationStack", HybridNavigationStackSpecSwift::Class::get());
+  }
+} // namespace margelo::nitro::navigation

package/nitrogen/generated/apple/ReactNitroNavigationAutolinking.mm

@@ -0,0 +1,24 @@
+///
+/// ReactNitroNavigationAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#include <ReactNitroNavigation/ReactNitroNavigationAutolinking.hpp>
+
+/**
+ * Registers all HybridObject classes of ReactNitroNavigation
+ * when the app loads, so JS can look them up by name.
+ */
+@interface ReactNitroNavigationAutolinking : NSObject
+@end
+
+@implementation ReactNitroNavigationAutolinking
+
++ (void)load {
+  margelo::nitro::navigation::registerHybridClasses();
+}
+
+@end

package/nitrogen/generated/apple/c++/HybridNavigationScreenSpecSwift.cpp

@@ -0,0 +1,54 @@
+///
+/// HybridNavigationScreenSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroNavigation/private/HybridNavigationScreenSpecSwift.hpp>
+#include <NitroModules/SwiftConverter.hpp>
+#include <NitroModules/SwiftResult.hpp>
+#include <optional>
+
+namespace margelo::nitro::navigation {
+
+  std::string HybridNavigationScreenSpecSwift::toString() {
+    return SwiftConverter<std::string, swift::String>::fromSwift(_swiftPart.toString());
+  }
+
+  // Properties
+
+  ::ReactNitroRenderer::HybridViewControllerSpec_cxx HybridNavigationScreenSpecSwift::getViewController() {
+    return _swiftPart.getViewController();
+  }
+
+  swift::Optional<swift::String> HybridNavigationScreenSpecSwift::getTitle() {
+    return _swiftPart.getTitle();
+  }
+
+  void HybridNavigationScreenSpecSwift::setTitle(const swift::Optional<swift::String>& title) {
+    return _swiftPart.setTitle(title);
+  }
+
+  // Methods
+
+  // Constructor
+
+  ::ReactNitroNavigation::HybridNavigationScreenSpec_cxx HybridNavigationScreenSpecSwift::constructor() {
+    auto __result = ::ReactNitroNavigation::HybridNavigationScreenSpec_cxx::constructor();
+    if (__result.hasError()) [[unlikely]] {
+      std::rethrow_exception(__result.error());
+    }
+    return ::ReactNitroNavigation::HybridNavigationScreenSpec_cxx::fromUnsafe(__result.value());
+  }
+
+  const std::shared_ptr<const HybridClass>& HybridNavigationScreenSpecSwift::Class::get() {
+    static const auto hybridClass = HybridClass::create<Class>([](HybridClass& clazz) {
+      clazz.registerHybridProperty("viewController", &HybridNavigationScreenSpecSwift::getViewController);
+      clazz.registerHybridProperty("title", &HybridNavigationScreenSpecSwift::getTitle, &HybridNavigationScreenSpecSwift::setTitle);
+      clazz.registerHybridConstructor(&HybridNavigationScreenSpecSwift::constructor);
+    });
+    return hybridClass;
+  }
+
+} // namespace margelo::nitro::navigation