react-native-nitro-modules 0.10.0 → 0.12.0

package/cpp/jsi/JSIConverter+HostObject.hpp

@@ -0,0 +1,73 @@
+//
+// Created by Marc Rousavy on 07.10.24.
+//
+
+#pragma once
+
+#include "IsSharedPtrTo.hpp"
+#include "NitroDefines.hpp"
+#include "TypeInfo.hpp"
+#include <jsi/jsi.h>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// jsi::HostObject <> {}
+template <typename T>
+struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::HostObject>>> final {
+  using TPointee = typename T::element_type;
+
+  static inline T fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+#ifdef NITRO_DEBUG
+    if (!arg.isObject()) [[unlikely]] {
+      if (arg.isUndefined()) [[unlikely]] {
+        throw jsi::JSError(runtime, invalidTypeErrorMessage("undefined", "It is undefined!"));
+      } else {
+        std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+        throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not an object!"));
+      }
+    }
+#endif
+    jsi::Object object = arg.asObject(runtime);
+
+#ifdef NITRO_DEBUG
+    if (!object.isHostObject<TPointee>(runtime)) [[unlikely]] {
+      if (!object.isHostObject(runtime)) [[unlikely]] {
+        std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+        throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not a HostObject at all!"));
+      } else {
+        std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+        throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is a different HostObject<T>!"));
+      }
+    }
+#endif
+    return object.getHostObject<TPointee>(runtime);
+  }
+
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const T& arg) {
+    if (arg == nullptr) [[unlikely]] {
+      std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();
+      throw jsi::JSError(runtime, "Cannot convert nullptr to HostObject<" + typeName + ">!");
+    }
+
+    return jsi::Object::createFromHostObject(runtime, arg);
+  }
+
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (value.isObject()) {
+      jsi::Object object = value.getObject(runtime);
+      return object.isHostObject<TPointee>(runtime);
+    }
+    return false;
+  }
+
+private:
+  static std::string invalidTypeErrorMessage(const std::string& typeDescription, const std::string& reason) {
+    std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();
+    return "Cannot convert \"" + typeDescription + "\" to HostObject<" + typeName + ">! " + reason;
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/jsi/JSIConverter+HybridObject.hpp

@@ -78,7 +78,7 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>
   }
 
 private:
-  static inline std::string invalidTypeErrorMessage(const std::string& typeDescription, const std::string& reason) {
+  static std::string invalidTypeErrorMessage(const std::string& typeDescription, const std::string& reason) {
     std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();
     return "Cannot convert \"" + typeDescription + "\" to NativeState<" + typeName + ">! " + reason;
   }

package/cpp/jsi/JSIConverter+Promise.hpp

@@ -34,6 +34,7 @@ struct JSIConverter<std::future<TResult>> final {
   static inline std::future<TResult> fromJSI(jsi::Runtime&, const jsi::Value&) {
     throw std::runtime_error("Promise cannot be converted to a native type - it needs to be awaited first!");
   }
+
   static inline jsi::Value toJSI(jsi::Runtime& runtime, std::future<TResult>&& arg) {
     auto sharedFuture = std::make_shared<std::future<TResult>>(std::move(arg));
     std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);

package/cpp/jsi/JSIConverter+Tuple.hpp

@@ -29,8 +29,8 @@ struct JSIConverter<std::tuple<Types...>> final {
     jsi::Array array = object.asArray(runtime);
     if (array.size(runtime) != sizeof...(Types)) [[unlikely]] {
       std::string types = TypeInfo::getFriendlyTypenames<Types...>();
-      throw std::runtime_error("The given JS Array has " + std::to_string(array.size(runtime)) + " items, but std::tuple<" + types +
-                               "> expects " + std::to_string(sizeof...(Types)) + " items.");
+      throw std::length_error("The given JS Array has " + std::to_string(array.size(runtime)) + " items, but std::tuple<" + types +
+                              "> expects " + std::to_string(sizeof...(Types)) + " items.");
     }
 
     return copyArrayItemsToTuple(runtime, array, std::index_sequence_for<Types...>{});

package/cpp/jsi/JSIConverter.hpp

@@ -184,6 +184,7 @@ struct JSIConverter<std::string> final {
 #include "JSIConverter+AnyMap.hpp"
 #include "JSIConverter+ArrayBuffer.hpp"
 #include "JSIConverter+Function.hpp"
+#include "JSIConverter+HostObject.hpp"
 #include "JSIConverter+HybridObject.hpp"
 #include "JSIConverter+Optional.hpp"
 #include "JSIConverter+Promise.hpp"

package/cpp/prototype/HybridObjectPrototype.cpp

@@ -31,7 +31,8 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
 
   // 2. We didn't find the given prototype in cache (either it's a new prototype, or a new runtime),
   //    so we need to create it. First, we need some helper methods from JS
-  Logger::log(LogLevel::Info, TAG, "Creating new JS prototype for C++ instance type \"%s\"...", prototype->getNativeInstanceId().name());
+  std::string typeName = TypeInfo::getFriendlyTypename(prototype->getNativeInstanceId(), true);
+  Logger::log(LogLevel::Info, TAG, "Creating new JS prototype for C++ instance type \"%s\"...", typeName.c_str());
   jsi::Object objectConstructor = runtime.global().getPropertyAsObject(runtime, "Object");
   jsi::Function objectCreate = objectConstructor.getPropertyAsFunction(runtime, "create");
   jsi::Function objectDefineProperty = objectConstructor.getPropertyAsFunction(runtime, "defineProperty");
@@ -71,8 +72,8 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
 
   // 7. In DEBUG, add a __type info to the prototype object.
 #ifdef NITRO_DEBUG
-  auto typeName = "Prototype<" + std::string(prototype->getNativeInstanceId().name()) + ">";
-  cachedObject->setProperty(runtime, "__type", jsi::String::createFromUtf8(runtime, typeName));
+  auto prototypeName = "Prototype<" + typeName + ">";
+  cachedObject->setProperty(runtime, "__type", jsi::String::createFromUtf8(runtime, prototypeName));
 #endif
 
   // 8. Return it!

package/cpp/threading/CallInvokerDispatcher.hpp

@@ -5,6 +5,9 @@
 #pragma once
 
 #include "Dispatcher.hpp"
+
+// This is react-native specific
+#if __has_include(<ReactCommon/CallInvoker.h>)
 #include <ReactCommon/CallInvoker.h>
 
 namespace margelo::nitro {
@@ -31,3 +34,5 @@ private:
 };
 
 } // namespace margelo::nitro
+
+#endif

package/cpp/utils/NitroDefines.hpp

@@ -48,4 +48,12 @@
 #define CLOSED_ENUM
 #endif
 
+#ifdef __APPLE__
+#define NONNULL _Nonnull
+#define NULLABLE _Nullable
+#else
+#define NONNULL
+#define NULLABLE
+#endif
+
 #endif /* NitroDefines_h */

package/cpp/utils/TypeInfo.hpp

@@ -7,10 +7,12 @@
 
 #pragma once
 
+#include "NitroDefines.hpp"
 #include <regex>
 #include <sstream>
 #include <string>
 #include <type_traits>
+#include <typeindex>
 
 #if __has_include(<cxxabi.h>)
 #include <cxxabi.h>
@@ -38,12 +40,10 @@ public:
     return std::regex_replace(original, re, replacement);
   }
 
-  /**
-   * Get a friendly name of the type `T` (if possible, demangled)
-   */
-  template <typename T>
-  static inline std::string getFriendlyTypename() {
-    std::string name = typeid(T).name();
+  static inline std::string demangleName(const std::string& typeName, bool removeNamespace = false) {
+#ifdef NITRO_DEBUG
+    // In debug, we demangle the name using Cxx ABI and prettify it.
+    std::string name = typeName;
 #if __has_include(<cxxabi.h>)
     int status = 0;
     char* demangled_name = abi::__cxa_demangle(name.c_str(), NULL, NULL, &status);
@@ -64,31 +64,51 @@ public:
         name,
         R"(std::__1::unordered_map<([^,]+), ([^>]+), std::__1::hash<\1>, std::__1::equal_to<\1>, std::__1::allocator<std::__1::pair<const \1, \2>>>)",
         "std::unordered_map<$1, $2>");
-    name = replaceRegex(name, R"(std::__1::unordered_set<([^>]+), std::__1::hash<\1>, std::__1::equal_to<\1>, std::__1::allocator<\1>>)",
-                        "std::unordered_set<$1>");
-    name = replaceRegex(name, R"(std::__1::list<([^>]+), std::__1::allocator<\1>>)", "std::list<$1>");
+
+    if (removeNamespace) [[unlikely]] {
+      // replace `margelo::nitro::HybridObject` -> `HybridObject`
+      size_t lastColon = name.rfind(':');
+      if (lastColon != std::string::npos) {
+        // Type contains a namespace - remove it
+        name = name.substr(lastColon + 1);
+      }
+    }
 
     return name;
+#else
+    // In release, we don't do any of that. Just return the ugly name.
+    return typeName;
+#endif
+  }
+
+  /**
+   * Get a friendly name of the given `type_info` (if possible, demangled)
+   */
+  static inline std::string getFriendlyTypename(const std::type_info& type, bool removeNamespace = false) {
+    std::string typeName = type.name();
+    return demangleName(typeName, removeNamespace);
   }
 
   /**
-   * Get a friendly name of the type `T` (if possible, demangled), without any namespaces
+   * Get a friendly name of the given `type_index` (if possible, demangled)
+   */
+  static inline std::string getFriendlyTypename(const std::type_index& typeIndex, bool removeNamespace = false) {
+    std::string typeName = typeIndex.name();
+    return demangleName(typeName, removeNamespace);
+  }
+
+  /**
+   * Get a friendly name of the type `T` (if possible, demangled)
    */
   template <typename T>
-  static inline std::string getFriendlyTypenameNoNamespace() {
-    std::string friendly = getFriendlyTypename<T>();
-    size_t lastColon = friendly.rfind(':');
-    if (lastColon == std::string::npos) {
-      // Type does not have any namespace (:), just return as is.
-      return friendly;
-    }
-    return friendly.substr(lastColon + 1);
+  static inline std::string getFriendlyTypename(bool removeNamespace = false) {
+    return getFriendlyTypename(typeid(T), removeNamespace);
   }
 
   template <typename... Types>
-  static inline std::string getFriendlyTypenames() {
+  static inline std::string getFriendlyTypenames(bool removeNamespace = false) {
     std::ostringstream stream;
-    ((stream << TypeInfo::getFriendlyTypename<Types>() << ", "), ...);
+    ((stream << TypeInfo::getFriendlyTypename<Types>(removeNamespace) << ", "), ...);
     std::string string = stream.str();
     return string.substr(0, string.length() - 2);
   }

package/ios/core/ArrayBufferHolder.hpp

@@ -35,7 +35,7 @@ public:
    * Once the `ArrayBuffer` is no longer in use, the given `deleteFunc` will be called with the given `deleteFuncContext`
    * as an argument. The caller is responsible for deleting `data` once this is called.
    */
-  static ArrayBufferHolder makeBuffer(uint8_t* data, size_t size, SwiftClosure destroy) {
+  static ArrayBufferHolder makeBuffer(uint8_t* _Nonnull data, size_t size, SwiftClosure destroy) {
     std::function<void()> deleteFunc = destroy.getFunction();
     auto arrayBuffer = ArrayBuffer::makeBuffer(data, size, std::move(deleteFunc));
     return ArrayBufferHolder(arrayBuffer);

package/ios/core/HybridObjectSpec.swift

@@ -10,7 +10,7 @@ import Foundation
 /**
  * A base protocol for all Swift-based Hybrid Objects.
  */
-public protocol HybridObjectSpec {
+public protocol HybridObjectSpec: AnyObject {
   /**
    * Holds the C++ HybridObject and it's context.
    * Use the default initializer in your implementation, C++ will set and get this value.

package/ios/platform/NitroLogger.mm

@@ -6,7 +6,6 @@
 //
 
 #include "NitroLogger.hpp"
-#include "AnyMapHolder.hpp"
 #include "NitroDefines.hpp"
 #include <Foundation/Foundation.h>
 
@@ -23,7 +22,7 @@ const char* levelToString(LogLevel level) {
     case LogLevel::Error:
       return "ERROR";
     default:
-      throw std::runtime_error("Invalid LogLevel!");
+      throw std::invalid_argument("Invalid LogLevel!");
   }
 }
 

package/ios/turbomodule/NativeNitroModules+NewArch.mm

@@ -0,0 +1,67 @@
+//
+//  NativeNitroModules+NewArch.mm
+//  DoubleConversion
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#import "NativeNitroModules.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "CallInvokerDispatcher.hpp"
+#import "InstallNitro.hpp"
+
+#import <ReactCommon/CallInvoker.h>
+#import <ReactCommon/RCTTurboModuleWithJSIBindings.h>
+
+using namespace facebook;
+using namespace margelo;
+
+// Make NativeNitroModules comply to RCTTurboModuleWithJSIBindings
+@interface NativeNitroModules () <RCTTurboModuleWithJSIBindings>
+@end
+
+/**
+ * NativeNitroModules implementation for the new architecture.
+ * This uses `installJSIBindingsWithRuntime:` to install the `global.NitroModulesProxy` into the JS Runtime.
+ */
+@implementation NativeNitroModules {
+  bool _didInstall;
+  std::weak_ptr<react::CallInvoker> _callInvoker;
+}
+RCT_EXPORT_MODULE(NitroModules)
+
+- (void)installJSIBindingsWithRuntime:(jsi::Runtime&)runtime {
+  // 1. Get CallInvoker we cached statically
+  auto callInvoker = _callInvoker.lock();
+  if (callInvoker == nullptr) {
+    throw std::runtime_error("Cannot install global.NitroModulesProxy - CallInvoker was null!");
+  }
+
+  // 2. Wrap CallInvoker as Dispatcher
+  auto dispatcher = std::make_shared<nitro::CallInvokerDispatcher>(callInvoker);
+
+  // 3. Install Nitro
+  nitro::install(runtime, dispatcher);
+  _didInstall = true;
+}
+
+- (NSString*)install {
+  if (_didInstall) {
+    // installJSIBindingsWithRuntime ran successfully.
+    return nil;
+  } else {
+    return @"installJSIBindingsWithRuntime: was not called - JSI Bindings could not be installed!";
+  }
+}
+
+- (std::shared_ptr<react::TurboModule>)getTurboModule:(const react::ObjCTurboModule::InitParams&)params {
+  // Cache the CallInvoker statically (weak) - we use it later in `installJSIBindingsWithRuntime:`.
+  _callInvoker = params.jsInvoker;
+  return std::make_shared<react::NativeNitroModulesSpecJSI>(params);
+}
+
+@end
+
+#endif

package/ios/turbomodule/NativeNitroModules+OldArch.mm

@@ -0,0 +1,71 @@
+//
+//  NativeNitroModules+OldArch.mm
+//  DoubleConversion
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#import "NativeNitroModules.h"
+
+#ifndef RCT_NEW_ARCH_ENABLED
+
+#import "CallInvokerDispatcher.hpp"
+#import "InstallNitro.hpp"
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTBridge.h>
+
+using namespace facebook;
+using namespace margelo;
+
+// forward-declaration (private API)
+@interface RCTBridge (JSIRuntime)
+- (void*)runtime;
+- (std::shared_ptr<react::CallInvoker>)jsCallInvoker;
+@end
+
+/**
+ * NativeNitroModules implementation for the old architecture.
+ * This uses `RCTBridge` to grab the `jsi::Runtime` and `react::CallInvoker`.
+ */
+@implementation NativeNitroModules
+RCT_EXPORT_MODULE(NitroModules)
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
+  try {
+    // 1. Cast RCTBridge to a RCTCxxBridge (ObjC)
+    RCTCxxBridge* cxxBridge = (RCTCxxBridge*)RCTBridge.currentBridge;
+    if (!cxxBridge) {
+      return @"RCTBridge is not a RCTCxxBridge!";
+    }
+
+    // 2. Access jsi::Runtime and cast from void*
+    jsi::Runtime* runtime = reinterpret_cast<jsi::Runtime*>(cxxBridge.runtime);
+    if (!runtime) {
+      return @"jsi::Runtime on RCTCxxBridge was null!";
+    }
+
+    // 3. Access react::CallInvoker
+    std::shared_ptr<react::CallInvoker> callInvoker = cxxBridge.jsCallInvoker;
+    if (!callInvoker) {
+      return @"react::CallInvoker on RCTCxxBridge was null!";
+    }
+
+    // 4. Wrap react::CallInvoker in nitro::Dispatcher
+    auto dispatcher = std::make_shared<nitro::CallInvokerDispatcher>(callInvoker);
+
+    // 5. Install Nitro
+    nitro::install(*runtime, dispatcher);
+    return nil;
+  } catch (std::exception& error) {
+    // ?. Any C++ error occurred (probably in nitro::install()?)
+    return [NSString stringWithCString:error.what() encoding:kCFStringEncodingUTF8];
+  } catch (...) {
+    // ?. Any non-std error occured (probably in ObjC code)
+    return @"Unknown non-std error occurred while installing Nitro!";
+  }
+}
+
+@end
+
+#endif

package/ios/turbomodule/NativeNitroModules.h

@@ -0,0 +1,22 @@
+//
+//  NativeNitroModules.h
+//  NitroModules
+//
+//  Created by Marc Rousavy on 07.10.24.
+//
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+// New Architecture uses the Codegen'd Spec (TurboModule)
+#import "NitroModulesSpec.h"
+@interface NativeNitroModules : NSObject <NativeNitroModulesSpec>
+@end
+
+#else
+
+// Old Architecture is an untyped RCTBridgeModule
+#import <React/RCTBridgeModule.h>
+@interface NativeNitroModules : NSObject <RCTBridgeModule>
+@end
+
+#endif

package/lib/BoxedHybridObject.d.ts

@@ -0,0 +1,12 @@
+import type { HybridObject } from './HybridObject';
+/**
+ * Represents a boxed {@linkcode HybridObject} that can later be unboxed again.
+ * This is implemented as a `jsi::HostObject`.
+ */
+export interface BoxedHybridObject<T extends HybridObject> {
+    /**
+     * Unboxes the {@linkcode HybridObject}.
+     * This can be called from a different Runtime than the one it was boxed in.
+     */
+    unbox(): T;
+}

package/lib/BoxedHybridObject.js

@@ -0,0 +1 @@
+export {};

package/lib/ModuleNotFoundError.js

@@ -20,26 +20,16 @@ function getFrameworkType() {
 }
 export class ModuleNotFoundError extends Error {
     constructor(cause) {
-        // TurboModule not found, something went wrong!
-        if (global.__turboModuleProxy == null) {
-            // TurboModules are not available/new arch is not enabled.
-            const message = 'Failed to get NitroModules: NitroModules require the new architecture to be enabled!';
-            const suggestions = [];
-            suggestions.push('Enable the new architecture in your app to use NitroModules. (See https://github.com/reactwg/react-native-new-architecture/blob/main/docs/enable-apps.md)');
-            const error = messageWithSuggestions(message, suggestions);
-            super(error, { cause: cause });
-            return;
-        }
         const framework = getFrameworkType();
         if (framework === 'expo-go') {
             super('NitroModules are not supported in Expo Go! Use EAS (`expo prebuild`) or eject to a bare workflow instead.');
             return;
         }
-        const message = 'Failed to get NitroModules: The native "NitroModules" TurboModule could not be found.';
+        const message = 'Failed to get NitroModules: The native "NitroModules" Turbo/Native-Module could not be found.';
         const suggestions = [];
         suggestions.push('Make sure react-native-nitro-modules/NitroModules is correctly autolinked (run `npx react-native config` to verify)');
-        suggestions.push('Make sure you enabled the new architecture (TurboModules) and CodeGen properly generated the "NativeNitroModules"/NitroModulesCxx specs. See https://github.com/reactwg/react-native-new-architecture/blob/main/docs/enable-apps.md');
-        suggestions.push('Make sure you are using react-native 0.74.0 or higher, because NitroModules are built with C++ TurboModules.');
+        suggestions.push('Make sure you enabled the new architecture (TurboModules) and CodeGen properly generated the "NativeNitroModules"/NitroModules specs. See https://github.com/reactwg/react-native-new-architecture/blob/main/docs/enable-apps.md');
+        suggestions.push('Make sure you are using react-native 0.75.0 or higher.');
         suggestions.push('Make sure you rebuilt the app.');
         if (framework === 'expo') {
             suggestions.push('Make sure you ran `expo prebuild`.');

package/lib/NitroModules.d.ts

@@ -1,83 +1 @@
-import type { HybridObject } from './HybridObject';
-/**
- * Represents a boxed {@linkcode HybridObject} that can later be unboxed again.
- * This is implemented as a `jsi::HostObject`.
- */
-export interface BoxedHybridObject<T extends HybridObject> {
-    /**
-     * Unboxes the {@linkcode HybridObject}.
-     * This can be called from a different Runtime than the one it was boxed in.
-     */
-    unbox(): T;
-}
-/**
- * A lazy proxy for initializing Nitro Modules HybridObjects.
- */
-export declare const NitroModules: {
-    /**
-     * Create a new instance of the `HybridObject` {@linkcode T}.
-     *
-     * {@linkcode T} has to be registered beforehand under the name {@linkcode name}
-     * in the native Nitro Modules `HybridObjectRegistry`.
-     *
-     * @param name The name of the `HybridObject` under which it was registered at.
-     * @returns An instance of {@linkcode T}
-     * @throws an Error if {@linkcode T} has not been registered under the name {@linkcode name}.
-     */
-    createHybridObject<T extends HybridObject<any>>(name: string): T;
-    /**
-     * Get a list of all registered Hybrid Objects.
-     */
-    getAllHybridObjectNames(): string[];
-    /**
-     * Returns whether a HybridObject under the given {@linkcode name} is registered, or not.
-     */
-    hasHybridObject(name: string): boolean;
-    /**
-     * Returns whether the given {@linkcode object} has a `NativeState` or not.
-     *
-     * This can be a quick way to check if an object is a valid {@linkcode HybridObject},
-     * and has not yet been disposed.
-     * @example
-     * ```ts
-     * const someObject = NitroModules.createHybridObject<Some>('Some')
-     * console.log(NitroModules.hasNativeState(someObject)) // -> true
-     * someObject.dispose()
-     * console.log(NitroModules.hasNativeState(someObject)) // -> false
-     * ```
-     */
-    hasNativeState(object: object): boolean;
-    /**
-     * Forcefully removes the `NativeState` of the given {@linkcode object}.
-     */
-    removeNativeState(object: object): void;
-    /**
-     * Gets the current build type configuration as defined in the `NITRO_DEBUG`
-     * preprocessor flag.
-     */
-    readonly buildType: "debug" | "release";
-    /**
-     * Boxes the given {@linkcode hybridObject} into a {@linkcode BoxedHybridObject<T>}, which can
-     * later be unboxed in a separate Runtime.
-     *
-     * While Nitro is runtime-agnostic and all `HybridObject`s can be used from a any Runtime,
-     * some threading/worklet libraries (like [react-native-worklets-core](https://github.com/margelo/react-native-worklets-core))
-     * do not yet support copying over `HybridObject`s as they use newer JSI APIs like `jsi::NativeState`.
-     *
-     * While those APIs are not yet available, you can still use every Nitro Hybrid Object in a separate
-     * Runtime/Worklet context by just boxing it yourself:
-     *
-     * @example
-     * ```ts
-     * const something = NitroModules.createHybridObject<Something>('Something')
-     * const boxed = NitroModules.box(something)
-     * const context = Worklets.createContext('DummyContext')
-     * context.runAsync(() => {
-     *   'worklet'
-     *   const unboxed = boxed.unbox()
-     *   console.log(unboxed.name) // --> "Something"
-     * })
-     * ```
-     */
-    box<T extends HybridObject>(hybridObject: T): BoxedHybridObject<T>;
-};
+export * from './turbomodule/NativeNitroModules';