react-nitro-core 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,100 @@
+// swift-tools-version: 6.4
+
+import Foundation
+import PackageDescription
+
+let name = "ReactNitroCore"
+let generated = "nitrogen/generated"
+let nitroDependencies: [Target.Dependency] = [
+  .product(name: "NitroModules", package: "nitro-core")
+]
+let cxxSettings: [CXXSetting] = [
+  .define("DEBUG", .when(configuration: .debug)),
+  .define("NDEBUG", .when(configuration: .release)),
+  .disableWarning("nullability-extension"),
+]
+let swiftSources = ["Sources/ReactNitroCore", "\(generated)/apple/swift"]
+let bridgeSources = ["c++", "ReactNitroCore-Swift-Cxx-Bridge.cpp", "ReactNitroCoreAutolinking.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")
+  ],
+  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/Sources/ReactNitroCore/AnimationFrameDisplayLink.swift

@@ -0,0 +1,83 @@
+internal import Foundation
+internal import NitroModules
+internal import QuartzCore
+
+#if os(macOS)
+  internal import CoreVideo
+#endif
+
+/// Delivers native display timestamps on the main queue.
+/// The owner serializes start/stop; iOS link mutations and all callbacks run on
+/// the main queue. The Core Video thread only enqueues a timestamp.
+final class AnimationFrameDisplayLink: NSObject, @unchecked Sendable {
+  private let callback: (Double) -> Void
+
+  #if os(macOS)
+    private var displayLink: CVDisplayLink?
+  #else
+    // Accessed only on the main queue, where the run loop owns the display link.
+    private var displayLink: CADisplayLink?
+  #endif
+
+  init(callback: @escaping (Double) -> Void) throws {
+    self.callback = callback
+    super.init()
+
+    #if os(macOS)
+      let result = CVDisplayLinkCreateWithActiveCGDisplays(&displayLink)
+      guard result == kCVReturnSuccess, let displayLink else {
+        throw RuntimeError("Could not create a display link (\(result)).")
+      }
+      let handlerResult = CVDisplayLinkSetOutputHandler(displayLink) {
+        [weak self] _, now, _, _, _ in
+        let timestamp = Double(now.pointee.hostTime) / CVGetHostClockFrequency()
+        DispatchQueue.main.async(
+          execute: DispatchWorkItem { [weak self] in
+            self?.callback(timestamp)
+          })
+        return kCVReturnSuccess
+      }
+      guard handlerResult == kCVReturnSuccess else {
+        throw RuntimeError("Could not configure a display link (\(handlerResult)).")
+      }
+    #endif
+  }
+
+  func start() throws {
+    #if os(macOS)
+      guard let displayLink, !CVDisplayLinkIsRunning(displayLink) else { return }
+      let result = CVDisplayLinkStart(displayLink)
+      guard result == kCVReturnSuccess else {
+        throw RuntimeError("Could not start a display link (\(result)).")
+      }
+    #else
+      DispatchQueue.main.async(
+        execute: DispatchWorkItem { [self] in
+          guard displayLink == nil else { return }
+          let link = CADisplayLink(target: self, selector: #selector(onFrame(_:)))
+          displayLink = link
+          link.add(to: .main, forMode: .common)
+        })
+    #endif
+  }
+
+  func stop() {
+    #if os(macOS)
+      if let displayLink, CVDisplayLinkIsRunning(displayLink) {
+        CVDisplayLinkStop(displayLink)
+      }
+    #else
+      DispatchQueue.main.async(
+        execute: DispatchWorkItem { [self] in
+          displayLink?.invalidate()
+          displayLink = nil
+        })
+    #endif
+  }
+
+  #if !os(macOS)
+    @objc private func onFrame(_ displayLink: CADisplayLink) {
+      callback(displayLink.timestamp)
+    }
+  #endif
+}

package/Sources/ReactNitroCore/HybridAnimationFrameScheduler.swift

@@ -0,0 +1,78 @@
+internal import Foundation
+internal import NitroModules
+internal import NitroModulesCxx
+internal import QuartzCore
+
+/// Owns frame requests separately from the platform display link.
+final class HybridAnimationFrameScheduler: HybridAnimationFrameSchedulerSpec {
+  private let timeOrigin = CACurrentMediaTime()
+  private let lock = NSLock()
+  private var callbacks: [Double: any Callback<(Double), Void>] = [:]
+  private var nextId: Double = 1
+  private var displayLink: AnimationFrameDisplayLink?
+  
+  func requestAnimationFrame(callback: any Callback<(Double), Void>) throws -> Double {
+    lock.lock()
+    defer { lock.unlock() }
+
+    if displayLink == nil {
+      displayLink = try AnimationFrameDisplayLink { [weak self] timestamp in
+        self?.fire(timestamp: timestamp)
+      }
+    }
+    if callbacks.isEmpty {
+      try displayLink?.start()
+    }
+    let id = nextId
+    nextId += 1
+    callbacks[id] = callback
+    return id
+  }
+
+  func cancelAnimationFrame(id: Double) throws {
+    lock.lock()
+    defer { lock.unlock() }
+    callbacks.removeValue(forKey: id)
+    if callbacks.isEmpty {
+      displayLink?.stop()
+    }
+  }
+
+  private func fire(timestamp: Double) {
+    lock.lock()
+    let ids = callbacks.keys.sorted()
+    lock.unlock()
+
+    let timestampMs = max(0, timestamp - timeOrigin) * 1_000
+    for id in ids {
+      lock.lock()
+      let callback = callbacks.removeValue(forKey: id)
+      lock.unlock()
+      // Remove each request just before calling it so cancellation can affect
+      // later callbacks, and newly requested callbacks wait for the next frame.
+      do {
+        try callback?.callSync(timestampMs)
+      } catch {
+        margelo.nitro.GlobalErrorHandler.reportError(.AnimationFrame, error.toCpp())
+      }
+    }
+
+    lock.lock()
+    if callbacks.isEmpty {
+      displayLink?.stop()
+    }
+    lock.unlock()
+  }
+
+  func dispose() {
+    lock.lock()
+    callbacks.removeAll()
+    displayLink?.stop()
+    displayLink = nil
+    lock.unlock()
+  }
+
+  deinit {
+    dispose()
+  }
+}

package/Sources/ReactNitroCore/HybridLogger.swift

@@ -0,0 +1,26 @@
+internal import Foundation
+internal import NitroModules
+internal import OSLog
+
+final class HybridLogger: HybridLoggerSpec {
+  private static let logger = Logger(
+    subsystem: Bundle.main.bundleIdentifier ?? "com.margelo.nitro",
+    category: "JavaScript"
+  )
+
+  static func debug(message: String) throws {
+    logger.debug("\(message, privacy: .public)")
+  }
+
+  static func info(message: String) throws {
+    logger.info("\(message, privacy: .public)")
+  }
+
+  static func warn(message: String) throws {
+    logger.warning("\(message, privacy: .public)")
+  }
+
+  static func error(message: String) throws {
+    logger.error("\(message, privacy: .public)")
+  }
+}

package/Sources/ReactNitroCore/HybridPerformance.swift

@@ -0,0 +1,19 @@
+internal import Darwin
+internal import Foundation
+internal import NitroModules
+
+final class HybridPerformance: HybridPerformanceSpec {
+  private let monotonicOrigin: UInt64
+  let timeOrigin: Double
+
+  override init() throws {
+    monotonicOrigin = clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW)
+    timeOrigin = Date().timeIntervalSince1970 * 1_000
+    try super.init()
+  }
+
+  func now() throws -> Double {
+    let elapsedNanoseconds = clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW) - monotonicOrigin
+    return Double(elapsedNanoseconds) / 1_000_000
+  }
+}

package/Sources/ReactNitroCore/HybridTimers.swift

@@ -0,0 +1,79 @@
+internal import Foundation
+internal import NitroModules
+internal import NitroModulesCxx
+
+final class HybridTimers: HybridTimersSpec {
+  // Timer events run on the main queue like JavaScript, but deinit can run on
+  // Hermes' finalizer thread.
+  private let lock = NSLock()
+  private var timers: [Double: DispatchSourceTimer] = [:]
+  private var nextId: Double = 1
+
+  func setTimeout(callback: any Callback<(), Void>, ms: Double) throws -> Double {
+    return scheduleTimer(ms: ms, repeats: false, callback: callback)
+  }
+
+  func setInterval(callback: any Callback<(), Void>, ms: Double) throws -> Double {
+    return scheduleTimer(ms: ms, repeats: true, callback: callback)
+  }
+
+  private func scheduleTimer(ms: Double, repeats: Bool, callback: any Callback<(), Void>) -> Double {
+    let normalizedMs = ms.isFinite && ms > 0 && ms <= Double(Int32.max) ? ms : 0
+    let delay = (repeats ? max(normalizedMs, 1) : normalizedMs) / 1_000
+    let timer = DispatchSource.makeTimerSource(queue: .main)
+
+    lock.lock()
+    defer { lock.unlock() }
+
+    let id = nextId
+    nextId += 1
+    timer.setEventHandler { [weak self] in
+      guard let timer = self?.getTimer(id: id, remove: !repeats) else { return }
+      if !repeats {
+        timer.cancel()
+      }
+      do {
+        try callback.callSync()
+      } catch {
+        margelo.nitro.GlobalErrorHandler.reportError(.Timer, error.toCpp())
+      }
+    }
+    if repeats {
+      timer.schedule(deadline: .now() + delay, repeating: delay)
+    } else {
+      timer.schedule(deadline: .now() + delay)
+    }
+    timers[id] = timer
+    timer.activate()
+    return id
+  }
+
+  func clearTimeout(id: Double) throws {
+    getTimer(id: id, remove: true)?.cancel()
+  }
+
+  func clearInterval(id: Double) throws {
+    try clearTimeout(id: id)
+  }
+
+  private func getTimer(id: Double, remove: Bool) -> DispatchSourceTimer? {
+    lock.lock()
+    defer { lock.unlock() }
+    return remove ? timers.removeValue(forKey: id) : timers[id]
+  }
+
+  func dispose() {
+    lock.lock()
+    let pendingTimers = timers
+    timers.removeAll()
+    lock.unlock()
+
+    for timer in pendingTimers.values {
+      timer.cancel()
+    }
+  }
+
+  deinit {
+    dispose()
+  }
+}

package/nitrogen/generated/.gitattributes

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

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

@@ -0,0 +1,90 @@
+///
+/// ReactNitroCore-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 <ReactNitroCore/private/ReactNitroCore-Swift-Cxx-Umbrella.hpp>
+#include <ReactNitroCore/private/HybridAnimationFrameSchedulerSpecSwift.hpp>
+#include <NitroModules/Callback.hpp>
+#include <ReactNitroCore/private/HybridLoggerSpecSwift.hpp>
+#include <ReactNitroCore/private/HybridPerformanceSpecSwift.hpp>
+#include <ReactNitroCore/private/HybridTimersSpecSwift.hpp>
+
+namespace margelo::nitro::core::swift_bridge {
+  std__shared_ptr_margelo__nitro__core__HybridAnimationFrameSchedulerSpec_ create_std__shared_ptr_margelo__nitro__core__HybridAnimationFrameSchedulerSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::core::HybridAnimationFrameSchedulerSpecSwift>(::ReactNitroCore::HybridAnimationFrameSchedulerSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__core__HybridAnimationFrameSchedulerSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::core::HybridAnimationFrameSchedulerSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridAnimationFrameSchedulerSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  Result<void, margelo::nitro::core::swift_bridge::ResultTag> callSync_Callback_void_double(const Callback_void_double& callback, double param0) noexcept {
+    try {
+      callback.callSync(param0);
+      return Result<void, margelo::nitro::core::swift_bridge::ResultTag>::withValue();
+    } catch (...) {
+      return Result<void, margelo::nitro::core::swift_bridge::ResultTag>::withError(std::current_exception());
+    }
+  }
+
+  Callback_void_double create_Callback_void_double(std::function<Result<void, margelo::nitro::core::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());
+      }
+    });
+  }
+
+  std__shared_ptr_margelo__nitro__core__HybridLoggerSpec_ create_std__shared_ptr_margelo__nitro__core__HybridLoggerSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::core::HybridLoggerSpecSwift>(::ReactNitroCore::HybridLoggerSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__core__HybridLoggerSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::core::HybridLoggerSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridLoggerSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std__shared_ptr_margelo__nitro__core__HybridPerformanceSpec_ create_std__shared_ptr_margelo__nitro__core__HybridPerformanceSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::core::HybridPerformanceSpecSwift>(::ReactNitroCore::HybridPerformanceSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__core__HybridPerformanceSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::core::HybridPerformanceSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridPerformanceSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std__shared_ptr_margelo__nitro__core__HybridTimersSpec_ create_std__shared_ptr_margelo__nitro__core__HybridTimersSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::core::HybridTimersSpecSwift>(::ReactNitroCore::HybridTimersSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__core__HybridTimersSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::core::HybridTimersSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridTimersSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  Result<void, margelo::nitro::core::swift_bridge::ResultTag> callSync_Callback_void(const Callback_void& callback) noexcept {
+    try {
+      callback.callSync();
+      return Result<void, margelo::nitro::core::swift_bridge::ResultTag>::withValue();
+    } catch (...) {
+      return Result<void, margelo::nitro::core::swift_bridge::ResultTag>::withError(std::current_exception());
+    }
+  }
+
+  Callback_void create_Callback_void(std::function<Result<void, margelo::nitro::core::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());
+      }
+    });
+  }
+} // namespace margelo::nitro::core::swift_bridge

package/nitrogen/generated/apple/ReactNitroCoreAppleCxx/ReactNitroCoreAppleCxx.cpp

@@ -0,0 +1,9 @@
+///
+/// ReactNitroCoreAppleCxx.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 <ReactNitroCoreAppleCxx/ReactNitroCoreAppleCxx.h>

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

@@ -0,0 +1,74 @@
+///
+/// ReactNitroCoreAppleCxx.h
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declaration of `HybridAnimationFrameSchedulerSpec_cxx` to properly resolve imports.
+namespace ReactNitroCore { class HybridAnimationFrameSchedulerSpec_cxx; }
+#include <NitroModules/Callback.hpp>
+#include <NitroModules/Result.hpp>
+// Forward declaration of `HybridLoggerSpec_cxx` to properly resolve imports.
+namespace ReactNitroCore { class HybridLoggerSpec_cxx; }
+namespace swift { class String; }
+// Forward declaration of `HybridPerformanceSpec_cxx` to properly resolve imports.
+namespace ReactNitroCore { class HybridPerformanceSpec_cxx; }
+// Forward declaration of `HybridTimersSpec_cxx` to properly resolve imports.
+namespace ReactNitroCore { class HybridTimersSpec_cxx; }
+#include <NitroModules/HybridObject.hpp>
+// Forward declaration of `HybridAnimationFrameSchedulerSpecSwift` to properly resolve imports.
+namespace margelo::nitro::core { class HybridAnimationFrameSchedulerSpecSwift; }
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/Promise.hpp>
+// Forward declaration of `HybridLoggerSpecSwift` to properly resolve imports.
+namespace margelo::nitro::core { class HybridLoggerSpecSwift; }
+// Forward declaration of `HybridPerformanceSpecSwift` to properly resolve imports.
+namespace margelo::nitro::core { class HybridPerformanceSpecSwift; }
+// Forward declaration of `HybridTimersSpecSwift` to properly resolve imports.
+namespace margelo::nitro::core { class HybridTimersSpecSwift; }
+
+namespace margelo::nitro::core::swift_bridge {
+  using std__shared_ptr_margelo__nitro__core__HybridAnimationFrameSchedulerSpec_ = std::shared_ptr<margelo::nitro::core::HybridAnimationFrameSchedulerSpecSwift>;
+  using std__weak_ptr_margelo__nitro__core__HybridAnimationFrameSchedulerSpec_ = std::weak_ptr<margelo::nitro::core::HybridAnimationFrameSchedulerSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__core__HybridAnimationFrameSchedulerSpec_ weakify_std__shared_ptr_margelo__nitro__core__HybridAnimationFrameSchedulerSpec_(const std__shared_ptr_margelo__nitro__core__HybridAnimationFrameSchedulerSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__core__HybridAnimationFrameSchedulerSpec_ create_std__shared_ptr_margelo__nitro__core__HybridAnimationFrameSchedulerSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__core__HybridAnimationFrameSchedulerSpec_(const std::shared_ptr<HybridObject>& value);
+  using Promise_void = Promise<void>;
+  // Distinct specializations prevent duplicate Swift metadata across module headers.
+  struct ResultTag {};
+  using Result_void = Result<void, margelo::nitro::core::swift_bridge::ResultTag>;
+  using Callback_void_double = Callback<void(double)>;
+  Result<void, margelo::nitro::core::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::core::swift_bridge::ResultTag>(double param0)> closure);
+  using Result_double = Result<double, margelo::nitro::core::swift_bridge::ResultTag>;
+  using Result_void_ = Result<void*, margelo::nitro::core::swift_bridge::ResultTag>;
+  using std__shared_ptr_margelo__nitro__core__HybridLoggerSpec_ = std::shared_ptr<margelo::nitro::core::HybridLoggerSpecSwift>;
+  using std__weak_ptr_margelo__nitro__core__HybridLoggerSpec_ = std::weak_ptr<margelo::nitro::core::HybridLoggerSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__core__HybridLoggerSpec_ weakify_std__shared_ptr_margelo__nitro__core__HybridLoggerSpec_(const std__shared_ptr_margelo__nitro__core__HybridLoggerSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__core__HybridLoggerSpec_ create_std__shared_ptr_margelo__nitro__core__HybridLoggerSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__core__HybridLoggerSpec_(const std::shared_ptr<HybridObject>& value);
+  using std__shared_ptr_margelo__nitro__core__HybridPerformanceSpec_ = std::shared_ptr<margelo::nitro::core::HybridPerformanceSpecSwift>;
+  using std__weak_ptr_margelo__nitro__core__HybridPerformanceSpec_ = std::weak_ptr<margelo::nitro::core::HybridPerformanceSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__core__HybridPerformanceSpec_ weakify_std__shared_ptr_margelo__nitro__core__HybridPerformanceSpec_(const std__shared_ptr_margelo__nitro__core__HybridPerformanceSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__core__HybridPerformanceSpec_ create_std__shared_ptr_margelo__nitro__core__HybridPerformanceSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__core__HybridPerformanceSpec_(const std::shared_ptr<HybridObject>& value);
+  using std__shared_ptr_margelo__nitro__core__HybridTimersSpec_ = std::shared_ptr<margelo::nitro::core::HybridTimersSpecSwift>;
+  using std__weak_ptr_margelo__nitro__core__HybridTimersSpec_ = std::weak_ptr<margelo::nitro::core::HybridTimersSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__core__HybridTimersSpec_ weakify_std__shared_ptr_margelo__nitro__core__HybridTimersSpec_(const std__shared_ptr_margelo__nitro__core__HybridTimersSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__core__HybridTimersSpec_ create_std__shared_ptr_margelo__nitro__core__HybridTimersSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__core__HybridTimersSpec_(const std::shared_ptr<HybridObject>& value);
+  using Callback_void = Callback<void()>;
+  Result<void, margelo::nitro::core::swift_bridge::ResultTag> callSync_Callback_void(const Callback_void& callback) noexcept;
+  Callback_void create_Callback_void(std::function<Result<void, margelo::nitro::core::swift_bridge::ResultTag>()> closure);
+} // namespace margelo::nitro::core::swift_bridge

package/nitrogen/generated/apple/ReactNitroCoreAutolinking.cpp

@@ -0,0 +1,26 @@
+///
+/// ReactNitroCoreAutolinking.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroCore/ReactNitroCoreAutolinking.hpp>
+#include <NitroModules/HybridClassRegistry.hpp>
+
+#include <ReactNitroCore/private/HybridAnimationFrameSchedulerSpecSwift.hpp>
+#include <ReactNitroCore/private/HybridLoggerSpecSwift.hpp>
+#include <ReactNitroCore/private/HybridPerformanceSpecSwift.hpp>
+#include <ReactNitroCore/private/HybridTimersSpecSwift.hpp>
+
+namespace margelo::nitro::core {
+  void registerHybridClasses() {
+    using namespace margelo::nitro;
+    using namespace margelo::nitro::core;
+
+    HybridClassRegistry::registerHybridClass("core.AnimationFrameScheduler", HybridAnimationFrameSchedulerSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("core.Logger", HybridLoggerSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("core.Performance", HybridPerformanceSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("core.Timers", HybridTimersSpecSwift::Class::get());
+  }
+} // namespace margelo::nitro::core

package/nitrogen/generated/apple/ReactNitroCoreAutolinking.mm

@@ -0,0 +1,24 @@
+///
+/// ReactNitroCoreAutolinking.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 <ReactNitroCore/ReactNitroCoreAutolinking.hpp>
+
+/**
+ * Registers all HybridObject classes of ReactNitroCore
+ * when the app loads, so JS can look them up by name.
+ */
+@interface ReactNitroCoreAutolinking : NSObject
+@end
+
+@implementation ReactNitroCoreAutolinking
+
++ (void)load {
+  margelo::nitro::core::registerHybridClasses();
+}
+
+@end