react-native-nitro-modules 0.10.0 → 0.11.0

package/lib/typescript/NitroModulesProxy.d.ts

@@ -0,0 +1,59 @@
+import type { HybridObject } from './HybridObject';
+import type { BoxedHybridObject } from './BoxedHybridObject';
+/**
+ * The Proxy class that acts as a main entry point for Nitro Modules in React Native.
+ *
+ * This is a `HybridObject` on the native side as well, and is expected to be
+ * installed into the runtime's `global` via the NativeModule/TurboModule's `install()` function.
+ */
+export interface NitroModulesProxy extends HybridObject {
+    /**
+     * 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>(name: string): T;
+    /**
+     * Returns whether a HybridObject under the given {@linkcode name} is registered, or not.
+     */
+    hasHybridObject(name: string): boolean;
+    /**
+     * Get a list of all registered Hybrid Objects.
+     */
+    getAllHybridObjectNames(): string[];
+    /**
+     * Gets the current build type configuration as defined in the `NITRO_DEBUG`
+     * preprocessor flag.
+     */
+    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>(obj: T): BoxedHybridObject<T>;
+}
+//# sourceMappingURL=NitroModulesProxy.d.ts.map

package/lib/typescript/NitroModulesProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NitroModulesProxy.d.ts","sourceRoot":"","sources":["../../src/NitroModulesProxy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAE5D;;;;;GAKG;AACH,MAAM,WAAW,iBAAkB,SAAQ,YAAY;IACrD;;;;;;;;;OASG;IACH,kBAAkB,CAAC,CAAC,SAAS,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAAA;IAC3D;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;IACtC;;OAEG;IACH,uBAAuB,IAAI,MAAM,EAAE,CAAA;IAEnC;;;OAGG;IACH,SAAS,EAAE,OAAO,GAAG,SAAS,CAAA;IAE9B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,GAAG,CAAC,CAAC,SAAS,YAAY,EAAE,GAAG,EAAE,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAA;CAC1D"}

package/lib/typescript/__tests__/index.test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.test.d.ts.map

package/lib/typescript/index.d.ts

@@ -0,0 +1,4 @@
+export * from './HybridObject';
+export * from './NitroModules';
+export * from './AnyMap';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/turbomodule/NativeNitroModules.d.ts

@@ -0,0 +1,8 @@
+import type { NitroModulesProxy } from '../NitroModulesProxy';
+export declare const NitroModules: NitroModulesProxy;
+declare global {
+    var __nitroModulesJSICache: {};
+    var __nitroDispatcher: {};
+}
+export declare function isRuntimeAlive(): boolean;
+//# sourceMappingURL=NativeNitroModules.d.ts.map

package/lib/typescript/turbomodule/NativeNitroModules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeNitroModules.d.ts","sourceRoot":"","sources":["../../../src/turbomodule/NativeNitroModules.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AA2B7D,eAAO,MAAM,YAAY,EAA+B,iBAAiB,CAAA;AAQzE,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,sBAAsB,EAAE,EAAE,CAAA;IAC9B,IAAI,iBAAiB,EAAE,EAAE,CAAA;CAC1B;AAED,wBAAgB,cAAc,YAI7B"}

package/lib/typescript/turbomodule/NativeNitroModules.web.d.ts

@@ -0,0 +1,3 @@
+export declare const NitroModules: {};
+export declare function isRuntimeAlive(): boolean;
+//# sourceMappingURL=NativeNitroModules.web.d.ts.map

package/lib/typescript/turbomodule/NativeNitroModules.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeNitroModules.web.d.ts","sourceRoot":"","sources":["../../../src/turbomodule/NativeNitroModules.web.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,IASxB,CAAA;AAED,wBAAgB,cAAc,IAAI,OAAO,CAExC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Insanely fast native C++, Swift or Kotlin modules with a statically compiled binding layer to JSI.",
   "main": "lib/index",
   "module": "lib/index",
@@ -147,5 +147,13 @@
         }
       ]
     ]
+  },
+  "codegenConfig": {
+    "name": "NitroModulesSpec",
+    "type": "modules",
+    "jsSrcsDir": "./src",
+    "android": {
+      "javaPackageName": "com.margelo.nitro"
+    }
   }
 }

package/src/BoxedHybridObject.ts

@@ -0,0 +1,13 @@
+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/src/ModuleNotFoundError.ts

@@ -32,20 +32,6 @@ function getFrameworkType(): 'react-native' | 'expo' | 'expo-go' {
 
 export class ModuleNotFoundError extends Error {
   constructor(cause?: unknown) {
-    // 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: string[] = []
-      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(
@@ -55,17 +41,15 @@ export class ModuleNotFoundError extends Error {
     }
 
     const message =
-      'Failed to get NitroModules: The native "NitroModules" TurboModule could not be found.'
+      'Failed to get NitroModules: The native "NitroModules" Turbo/Native-Module could not be found.'
     const suggestions: string[] = []
     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.'
+      '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.74.0 or higher.')
     suggestions.push('Make sure you rebuilt the app.')
     if (framework === 'expo') {
       suggestions.push('Make sure you ran `expo prebuild`.')

package/src/NitroModules.ts

@@ -1,108 +1,2 @@
-import { getNativeNitroModules } from './NitroModulesTurboModule'
-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 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 {
-    const nitro = getNativeNitroModules()
-    const instance = nitro.createHybridObject(name)
-    return instance as T
-  },
-  /**
-   * Get a list of all registered Hybrid Objects.
-   */
-  getAllHybridObjectNames(): string[] {
-    const nitro = getNativeNitroModules()
-    return nitro.getAllHybridObjectNames()
-  },
-  /**
-   * Returns whether a HybridObject under the given {@linkcode name} is registered, or not.
-   */
-  hasHybridObject(name: string): boolean {
-    const nitro = getNativeNitroModules()
-    return nitro.hasHybridObject(name)
-  },
-  /**
-   * 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 {
-    const nitro = getNativeNitroModules()
-    return nitro.hasNativeState(object)
-  },
-  /**
-   * Forcefully removes the `NativeState` of the given {@linkcode object}.
-   */
-  removeNativeState(object: object): void {
-    const nitro = getNativeNitroModules()
-    nitro.removeNativeState(object)
-  },
-  /**
-   * Gets the current build type configuration as defined in the `NITRO_DEBUG`
-   * preprocessor flag.
-   */
-  get buildType(): 'debug' | 'release' {
-    const nitro = getNativeNitroModules()
-    return nitro.buildType
-  },
-  /**
-   * 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> {
-    const nitro = getNativeNitroModules()
-    return nitro.box(hybridObject) as BoxedHybridObject<T>
-  },
-}
+// Re-exports the platform specific `NitroModulesProxy` (or a stub-implementation if not found)
+export * from './turbomodule/NativeNitroModules'

package/src/NitroModulesProxy.ts

@@ -0,0 +1,61 @@
+import type { HybridObject } from './HybridObject'
+import type { BoxedHybridObject } from './BoxedHybridObject'
+
+/**
+ * The Proxy class that acts as a main entry point for Nitro Modules in React Native.
+ *
+ * This is a `HybridObject` on the native side as well, and is expected to be
+ * installed into the runtime's `global` via the NativeModule/TurboModule's `install()` function.
+ */
+export interface NitroModulesProxy extends HybridObject {
+  /**
+   * 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>(name: string): T
+  /**
+   * Returns whether a HybridObject under the given {@linkcode name} is registered, or not.
+   */
+  hasHybridObject(name: string): boolean
+  /**
+   * Get a list of all registered Hybrid Objects.
+   */
+  getAllHybridObjectNames(): string[]
+
+  /**
+   * Gets the current build type configuration as defined in the `NITRO_DEBUG`
+   * preprocessor flag.
+   */
+  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>(obj: T): BoxedHybridObject<T>
+}

package/src/turbomodule/NativeNitroModules.ts

@@ -0,0 +1,48 @@
+import type { TurboModule } from 'react-native'
+import { TurboModuleRegistry } from 'react-native'
+import { ModuleNotFoundError } from '../ModuleNotFoundError'
+import type { NitroModulesProxy } from '../NitroModulesProxy'
+
+interface Spec extends TurboModule {
+  /**
+   * Installs `NitroModulesProxy` into this JS Runtime's `global`.
+   * Also sets up a Dispatcher for the main JS Runtime.
+   * @returns A `string` error message if this function failed to run, or `undefined` if everything went successful.
+   */
+  install(): string | undefined
+}
+
+// 1. Get (and initialize) the TurboModule
+let turboModule: Spec | undefined
+try {
+  turboModule = TurboModuleRegistry.getEnforcing<Spec>('NitroModules')
+} catch (e) {
+  throw new ModuleNotFoundError(e)
+}
+
+// 2. Install Dispatcher and install `NitroModulesProxy` into the Runtime's `global`
+const errorMessage = turboModule.install()
+if (errorMessage != null) {
+  throw new Error(`Failed to install Nitro: ${errorMessage}`)
+}
+
+// 3. Find `NitroModulesProxy` in `global`
+// @ts-expect-error
+export const NitroModules = global.NitroModulesProxy as NitroModulesProxy
+if (NitroModules == null) {
+  const cause = new Error(
+    'NitroModules was installed, but `global.NitroModulesProxy` was null!'
+  )
+  throw new ModuleNotFoundError(cause)
+}
+
+declare global {
+  var __nitroModulesJSICache: {}
+  var __nitroDispatcher: {}
+}
+
+export function isRuntimeAlive() {
+  const cache = global.__nitroModulesJSICache
+  const dispatcher = global.__nitroDispatcher
+  return cache != null && dispatcher != null
+}

package/src/turbomodule/NativeNitroModules.web.ts

@@ -0,0 +1,16 @@
+import { Platform } from 'react-native'
+
+export const NitroModules = new Proxy(
+  {},
+  {
+    get: () => {
+      throw new Error(
+        `Native NitroModules are not available on ${Platform.OS}! Make sure you're not calling getNativeNitroModules() in a ${Platform.OS} (.${Platform.OS}.ts) environment.`
+      )
+    },
+  }
+)
+
+export function isRuntimeAlive(): boolean {
+  return false
+}

package/android/src/main/java/com/margelo/nitro/NitroModulesPackage.java

@@ -1,30 +0,0 @@
-package com.margelo.nitro;
-
-import android.util.Log;
-import androidx.annotation.Nullable;
-
-import com.facebook.react.bridge.NativeModule;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.module.model.ReactModuleInfoProvider;
-import com.facebook.react.TurboReactPackage;
-
-import java.util.HashMap;
-
-public class NitroModulesPackage extends TurboReactPackage {
-  static {
-    JNIOnLoad.initializeNativeNitro();
-  }
-
-  @Nullable
-  @Override
-  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
-    return null;
-  }
-
-  @Override
-  public ReactModuleInfoProvider getReactModuleInfoProvider() {
-    return () -> {
-      return new HashMap<>();
-    };
-  }
-}

package/cpp/turbomodule/NativeNitroModules.cpp

@@ -1,146 +0,0 @@
-//
-//  NativeNitroModules.cpp
-//  NitroModules
-//
-//  Created by Marc Rousavy on 21.06.24.
-//
-
-#include "NativeNitroModules.hpp"
-#include "BoxedHybridObject.hpp"
-#include "CallInvokerDispatcher.hpp"
-#include "Dispatcher.hpp"
-#include "HybridObjectRegistry.hpp"
-#include "NitroDefines.hpp"
-
-namespace facebook::react {
-
-using namespace margelo::nitro;
-
-NativeNitroModules::NativeNitroModules(std::shared_ptr<CallInvoker> jsInvoker)
-    : TurboModule(kModuleName, jsInvoker), _callInvoker(jsInvoker) {}
-
-jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID& propName) {
-  std::string name = propName.utf8(runtime);
-
-  if (name == "install") {
-    return jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, "install"), 0,
-        [this](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
-          install(runtime);
-          return jsi::Value::undefined();
-        });
-  }
-  if (name == "createHybridObject") {
-    return jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, "createHybridObject"), 1,
-        [this](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
-#ifdef NITRO_DEBUG
-          if (count != 1) [[unlikely]] {
-            throw jsi::JSError(runtime,
-                               "NitroModules.createHybridObject(..) expects 1 argument, but " + std::to_string(count) + " were supplied!");
-          }
-#endif
-          jsi::String objectName = args[0].asString(runtime);
-          return createHybridObject(runtime, objectName);
-        });
-  }
-  if (name == "hasHybridObject") {
-    return jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, "hasHybridObject"), 1,
-        [this](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
-#ifdef NITRO_DEBUG
-          if (count != 1) [[unlikely]] {
-            throw jsi::JSError(runtime,
-                               "NitroModules.hasHybridObject(..) expects 1 argument (name), but received " + std::to_string(count) + "!");
-          }
-#endif
-          jsi::String objectName = args[0].asString(runtime);
-          return hasHybridObject(runtime, objectName);
-        });
-  }
-  if (name == "getAllHybridObjectNames") {
-    return jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, "getAllHybridObjectNames"), 0,
-                                                 [this](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args,
-                                                        size_t count) -> jsi::Value { return getAllHybridObjectNames(runtime); });
-  }
-  if (name == "hasNativeState") {
-    return jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, "hasNativeState"), 1,
-        [](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
-          jsi::Object object = args[0].asObject(runtime);
-          bool has = object.hasNativeState(runtime) && object.getNativeState(runtime) != nullptr;
-          return jsi::Value(has);
-        });
-  }
-  if (name == "removeNativeState") {
-    return jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, "removeNativeState"), 1,
-        [](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
-          jsi::Object object = args[0].asObject(runtime);
-          object.setNativeState(runtime, nullptr);
-          return jsi::Value::undefined();
-        });
-  }
-  if (name == "box") {
-    return jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, "box"), 1,
-        [](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
-          jsi::Object object = args[0].asObject(runtime);
-#ifdef NITRO_DEBUG
-          if (!object.hasNativeState(runtime)) {
-            std::string stringified = args[0].toString(runtime).utf8(runtime);
-            throw std::runtime_error("Cannot box object " + stringified + " - it does not have a NativeState!");
-          }
-#endif
-
-          std::shared_ptr<jsi::NativeState> nativeState = object.getNativeState(runtime);
-          std::shared_ptr<HybridObject> maybeHybridObject = std::dynamic_pointer_cast<HybridObject>(nativeState);
-          if (maybeHybridObject == nullptr) {
-            std::string stringified = args[0].toString(runtime).utf8(runtime);
-            throw std::runtime_error("Cannot box object " + stringified + " - it has a NativeState, but it's not a HybridObject!");
-          }
-
-          auto boxed = std::make_shared<BoxedHybridObject>(maybeHybridObject);
-          return jsi::Object::createFromHostObject(runtime, boxed);
-        });
-  }
-  if (name == "buildType") {
-#ifdef NITRO_DEBUG
-    return jsi::String::createFromAscii(runtime, "debug");
-#else
-    return jsi::String::createFromAscii(runtime, "release");
-#endif
-  }
-
-  return jsi::Value::undefined();
-}
-
-void NativeNitroModules::install(jsi::Runtime& runtime) {
-  // Installs the global Dispatcher mechanism into this Runtime.
-  // This allows creating Promises and calling back to JS.
-  auto dispatcher = std::make_shared<CallInvokerDispatcher>(_callInvoker);
-  Dispatcher::installRuntimeGlobalDispatcher(runtime, dispatcher);
-}
-
-jsi::Value NativeNitroModules::createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName) {
-  auto name = hybridObjectName.utf8(runtime);
-  auto hybridObject = HybridObjectRegistry::createHybridObject(name);
-  return hybridObject->toObject(runtime);
-}
-
-jsi::Value NativeNitroModules::hasHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName) {
-  std::string name = hybridObjectName.utf8(runtime);
-  bool exists = HybridObjectRegistry::hasHybridObject(name);
-  return exists;
-}
-
-jsi::Value NativeNitroModules::getAllHybridObjectNames(jsi::Runtime& runtime) {
-  std::vector<std::string> keys = HybridObjectRegistry::getAllHybridObjectNames();
-  jsi::Array array(runtime, keys.size());
-  for (size_t i = 0; i < keys.size(); i++) {
-    array.setValueAtIndex(runtime, i, jsi::String::createFromUtf8(runtime, keys[i]));
-  }
-  return array;
-}
-
-} // namespace facebook::react

package/cpp/turbomodule/NativeNitroModules.h

@@ -1,8 +0,0 @@
-//
-// Created by Marc Rousavy on 26.07.24.
-//
-
-#pragma once
-
-// Forward include, because in react-native they use `.h` instead of `.hpp`
-#include "NativeNitroModules.hpp"

package/cpp/turbomodule/NativeNitroModules.hpp

@@ -1,38 +0,0 @@
-//
-//  NativeNitroModules.hpp
-//  NitroModules
-//
-//  Created by Marc Rousavy on 21.06.24.
-//
-
-#pragma once
-
-#include <ReactCommon/TurboModule.h>
-
-namespace facebook::react {
-
-using namespace facebook;
-
-// The base C++-based TurboModule. This is the entry point where all nitro modules get initialized.
-class NativeNitroModules : public TurboModule {
-public:
-  explicit NativeNitroModules(std::shared_ptr<CallInvoker> jsInvoker);
-
-public:
-  jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName) override;
-
-  // Setup
-  void install(jsi::Runtime& runtime);
-  // Hybrid Objects stuff
-  jsi::Value createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName);
-  jsi::Value hasHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName);
-  jsi::Value getAllHybridObjectNames(jsi::Runtime& runtime);
-
-public:
-  constexpr static auto kModuleName = "NitroModulesCxx";
-
-private:
-  std::shared_ptr<CallInvoker> _callInvoker;
-};
-
-} // namespace facebook::react

package/cpp/turbomodule/RegisterNativeNitroModules.cpp

@@ -1,33 +0,0 @@
-//
-//  RegisterNativeNitroModules.cpp
-//  DoubleConversion
-//
-//  Created by Marc Rousavy on 21.06.24.
-//
-
-#include "RegisterNativeNitroModules.hpp"
-#include "NativeNitroModules.hpp"
-#include <memory>
-#include <string>
-
-#if __has_include(<ReactCommon/CallInvoker.h>)
-// Android style imports
-#include <ReactCommon/CallInvoker.h>
-#include <ReactCommon/CxxTurboModuleUtils.h>
-#else
-// iOS style imports
-#include <React-callinvoker/ReactCommon/CallInvoker.h>
-#include <ReactCommon/ReactCommon/CxxTurboModuleUtils.h>
-#endif
-
-namespace margelo::nitro {
-
-using namespace facebook;
-
-void RegisterNativeNitroModules::registerNativeNitroModules() {
-  react::registerCxxModuleToGlobalModuleMap(
-      std::string(react::NativeNitroModules::kModuleName),
-      [&](std::shared_ptr<react::CallInvoker> jsInvoker) { return std::make_shared<react::NativeNitroModules>(jsInvoker); });
-}
-
-} // namespace margelo::nitro