react-native-nitro-modules 0.4.1 → 0.5.0

package/NitroModules.podspec

@@ -38,6 +38,7 @@ Pod::Spec.new do |s|
     "cpp/utils/NitroDefines.hpp",
     # Public iOS-specific headers that will be exposed in modulemap (for Swift)
     "ios/core/ArrayBufferHolder.hpp",
+    "ios/core/PromiseHolder.hpp",
     "ios/core/HybridContext.hpp",
   ]
 

package/README.md

@@ -162,7 +162,7 @@ The following C++ / JS types are supported out of the box:
   <tr>
     <td><code>Promise&lt;T&gt;</code></td>
     <td><code>std::future&lt;T&gt;</code></td>
-    <td>❌</td>
+    <td><code><a href="./ios/core/Promise.swift">Promise&lt;T&gt;</a></code></td>
   </tr>
   <tr>
     <td><code>(TArgs...) =&gt; void</code></td>
@@ -185,7 +185,7 @@ The following C++ / JS types are supported out of the box:
     <td><code><a href="./ios/core/ArrayBufferHolder.hpp">ArrayBufferHolder</a></code></td>
   </tr>
   <tr>
-    <td><code><a href="./src/HybridObject.ts">HybridObject</a></code></td>
+    <td>..any <code><a href="./src/HybridObject.ts">HybridObject</a></code></td>
     <td><code>std::shared_ptr&lt;<a href="./cpp/core/HybridObject.hpp">HybridObject</a>&gt;</code></td>
     <td><code><a href="./ios/core/HybridObjectSpec.swift">HybridObjectSpec</a></code></td>
   </tr>

package/cpp/core/ArrayBuffer.hpp

@@ -33,6 +33,12 @@ using DeleteFn = void (*)(void* context);
  *   When this `ArrayBuffer` gets deleted, the memory will not be freed explicitly, as someone else owns it.
  */
 class ArrayBuffer : public jsi::MutableBuffer {
+public:
+  ArrayBuffer() = default;
+  ArrayBuffer(const ArrayBuffer&) = delete;
+  ArrayBuffer(ArrayBuffer&&) = delete;
+  virtual ~ArrayBuffer() = default;
+  
 public:
   /**
    * Returns whether this `ArrayBuffer` is actually owning the data,
@@ -40,7 +46,8 @@ public:
    * memory that we didn't allocate, or from JS - which can be deleted at any point).
    */
   virtual bool isOwner() const noexcept = 0;
-
+  
+public:
   /**
    * Create a new `NativeArrayBuffer` that wraps the given data (without copy) of the given size,
    * and calls `deleteFunc` with the given `deleteFuncContext` as a parameter in which `data` should be deleted.

package/cpp/jsi/JSIConverter+Function.hpp

@@ -67,9 +67,9 @@ struct JSIConverter<std::function<ReturnType(Args...)>> {
     };
   }
 
-  static inline jsi::Value toJSI(jsi::Runtime& runtime, std::function<ReturnType(Args...)>&& function) {
-    jsi::HostFunctionType jsFunction = [function = std::move(function)](jsi::Runtime& runtime, const jsi::Value& thisValue,
-                                                                        const jsi::Value* args, size_t count) -> jsi::Value {
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::function<ReturnType(Args...)>& function) {
+    jsi::HostFunctionType jsFunction = [function](jsi::Runtime& runtime, const jsi::Value& thisValue,
+                                                  const jsi::Value* args, size_t count) -> jsi::Value {
       if (count != sizeof...(Args)) [[unlikely]] {
         throw jsi::JSError(runtime, "Function expected " + std::to_string(sizeof...(Args)) + " arguments, but received " +
                                         std::to_string(count) + "!");

package/cpp/jsi/JSIConverter+Promise.hpp

@@ -7,7 +7,8 @@
 // Forward declare a few of the common types that might have cyclic includes.
 namespace margelo::nitro {
 class Dispatcher;
-class Promise;
+
+class JSPromise;
 
 template <typename T, typename Enable>
 struct JSIConverter;

package/ios/core/ArrayBufferHolder.hpp

@@ -8,7 +8,7 @@
 #pragma once
 
 #include "ArrayBuffer.hpp"
-#include "NitroDefines.hpp"
+#include <swift/bridging>
 #include <memory>
 
 namespace margelo::nitro {
@@ -53,7 +53,16 @@ public:
     return _arrayBuffer->size();
   }
 
-  bool isOwner() const SWIFT_COMPUTED_PROPERTY {
+  /**
+   * Whether the underlying `ArrayBuffer` actually owns the data it points to, or not.
+   *
+   * - If an `ArrayBuffer` owns the data, it is likely an ArrayBuffer created on the native side (C++/Swift).
+   *   This means the `ArrayBuffer` is safe to access as long as you have a reference to it, and cannot be deleted otherwise.
+   * - If an `ArrayBuffer` doesn't own the data, it is likely an ArrayBuffer coming from JS.
+   *   This means the `ArrayBuffer` is **NOT** safe to access outside of the synchronous function's scope.
+   *   If you plan on hopping do a different Thread, or storing a long-lived reference to it, make sure to **copy** the data.
+   */
+  bool getIsOwner() const SWIFT_COMPUTED_PROPERTY {
     return _arrayBuffer->isOwner();
   }
 

package/ios/core/{ArrayBuffer.swift → ArrayBufferHolder.swift}

@@ -1,5 +1,5 @@
 //
-//  ArrayBuffer.swift
+//  ArrayBufferHolder.swift
 //  NitroModules
 //
 //  Created by Marc Rousavy on 17.07.24.
@@ -7,6 +7,12 @@
 
 import Foundation
 
+/**
+ * Holds instances of `std::shared_ptr<ArrayBuffer>`, which can be passed
+ * between native and JS **without copy**.
+ *
+ * See `data`, `size` and `isOwning`.
+ */
 public typealias ArrayBufferHolder = margelo.nitro.ArrayBufferHolder
 
 public extension ArrayBufferHolder {
@@ -16,22 +22,13 @@ public extension ArrayBufferHolder {
    * When the `ArrayBuffer` is no longer used, `onDelete` will be called, in which
    * you as a caller are responsible for deleting `data`.
    */
-  static func wrap(wrappingDataWithoutCopy data: UnsafeMutablePointer<UInt8>,
+  static func wrap(dataWithoutCopy data: UnsafeMutablePointer<UInt8>,
                    size: Int,
                    onDelete delete: @escaping () -> Void) -> ArrayBufferHolder {
     // Convert escaping Swift closure to a `void*`
-    let wrapper = ClosureWrapper(closure: delete)
-    let wrappedClosure = Unmanaged.passRetained(wrapper).toOpaque()
-    
-    return ArrayBufferHolder.makeBuffer(data, size, { context in
-      guard let context else {
-        fatalError("Context was null, even though we created one!")
-      }
-      // Convert `void*` to a Swift closure
-      let closure = Unmanaged<ClosureWrapper>.fromOpaque(context).takeRetainedValue()
-      // Call it (deleteFunc)
-      closure.invoke()
-    }, wrappedClosure)
+    let (wrappedClosure, context) = ClosureWrapper.wrap(closure: delete)
+    // Create ArrayBufferHolder with our wrapped Swift closure to make it callable as a C-function pointer
+    return ArrayBufferHolder.makeBuffer(data, size, wrappedClosure, context)
   }
   
   /**

package/ios/core/Promise.swift

@@ -0,0 +1,162 @@
+//
+//  Promise.swift
+//  NitroModules
+//
+//  Created by Marc Rousavy on 15.08.24.
+//
+
+import Foundation
+
+/**
+ * Represents a Promise that can be passed to JS.
+ *
+ * Create a new Promise with the following APIs:
+ * - `Promise<T>.async { ... }` - Creates a new Promise that runs the given code in a Swift `async`/`await` Task.
+ * - `Promise<T>.parallel { ... }` - Creates a new Promise that runs the given code in a parallel `DispatchQueue`.
+ * - `Promise<T>.resolved(withResult:)` - Creates a new already resolved Promise.
+ * - `Promise<T>.rejected(withError:)` - Creates a new already rejected Promise.
+ * - `Promise<T>()` - Creates a new Promise with fully manual control over the `resolve(..)`/`reject(..)` functions.
+ */
+public class Promise<T> {
+  private enum State {
+    case result(T)
+    case error(Error)
+  }
+  
+  private var state: State?
+  private var onResolvedListeners: [(T) -> Void] = []
+  private var onRejectedListeners: [(Error) -> Void] = []
+  
+  /**
+   * Create a new pending Promise.
+   * It can (and must) be resolved **or** rejected later.
+   */
+  public init() {
+    state = nil
+  }
+  
+  deinit {
+    if state == nil {
+      print("⚠️ Promise<\(String(describing: T.self))> got destroyed, but was never resolved or rejected! It is probably left hanging in JS now.")
+    }
+  }
+  
+  /**
+   * Resolves this `Promise<T>` with the given `T` and notifies all listeners.
+   */
+  public func resolve(withResult result: T) {
+    guard state == nil else {
+      fatalError("Failed to resolve promise with \(result) - it has already been resolved or rejected!")
+    }
+    state = .result(result)
+    onResolvedListeners.forEach { listener in listener(result) }
+  }
+  
+  /**
+   * Rejects this `Promise<T>` with the given `Error` and notifies all listeners.
+   */
+  public func reject(withError error: Error) {
+    guard state == nil else {
+      fatalError("Failed to reject promise with \(error) - it has already been resolved or rejected!")
+    }
+    state = .error(error)
+    onRejectedListeners.forEach { listener in listener(error) }
+  }
+}
+
+/**
+ * Extensions to easily create new Promises.
+ */
+extension Promise {
+  /**
+   * Create a new `Promise<T>` already resolved with the given `T`.
+   */
+  public static func resolved(withResult result: T) -> Promise {
+    let promise = Promise()
+    promise.state = .result(result)
+    return promise
+  }
+  
+  /**
+   * Create a new `Promise<T>` already rejected with the given `Error`.
+   */
+  public static func rejected(withError error: Error) -> Promise {
+    let promise = Promise()
+    promise.state = .error(error)
+    return promise
+  }
+  
+  /**
+   * Create a new `Promise<T>` that runs the given `async` code in a `Task`.
+   * This does not necessarily run the code in a different Thread, but supports Swift's `async`/`await`.
+   */
+  public static func `async`(_ priority: TaskPriority? = nil,
+                             _ run: @escaping () async throws -> T) -> Promise {
+    let promise = Promise()
+    Task(priority: priority) {
+      do {
+        let result = try await run()
+        promise.resolve(withResult: result)
+      } catch {
+        promise.reject(withError: error)
+      }
+    }
+    return promise
+  }
+  
+  /**
+   * Create a new `Promise<T>` that runs the given `run` function on a parallel Thread/`DispatchQueue`.
+   */
+  public static func parallel(_ queue: DispatchQueue = .global(),
+                              _ run: @escaping () throws -> T) -> Promise {
+    let promise = Promise()
+    queue.async {
+      do {
+        let result = try run()
+        promise.resolve(withResult: result)
+      } catch {
+        promise.reject(withError: error)
+      }
+    }
+    return promise
+  }
+}
+
+/**
+ * Extensions to support then/catch syntax.
+ */
+extension Promise {
+  /**
+   * Add a continuation listener to this `Promise<T>`.
+   * Once the `Promise<T>` resolves, the `onResolvedListener` will be called.
+   */
+  @discardableResult
+  public func then(_ onResolvedListener: @escaping (T) -> Void) -> Promise {
+    switch state {
+    case .result(let result):
+      onResolvedListener(result)
+      break
+    default:
+      onResolvedListeners.append(onResolvedListener)
+      break
+    }
+    return self
+  }
+  
+  /**
+   * Add an error continuation listener to this `Promise<T>`.
+   * Once the `Promise<T>` rejects, the `onRejectedListener` will be called with the error.
+   */
+  @discardableResult
+  public func `catch`(_ onRejectedListener: @escaping (Error) -> Void) -> Promise {
+    switch state {
+    case .error(let error):
+      onRejectedListener(error)
+      break
+    default:
+      onRejectedListeners.append(onRejectedListener)
+      break
+    }
+    return self
+  }
+}

package/ios/core/PromiseHolder.hpp

@@ -0,0 +1,82 @@
+//
+//  PromiseHolder.hpp
+//  Pods
+//
+//  Created by Marc Rousavy on 15.08.24.
+//
+
+#pragma once
+
+#include <future>
+#include <string>
+
+namespace margelo::nitro {
+
+/**
+ * Holds a `std::promise` that can be accessed from Swift using proper ref management.
+ */
+template <typename T>
+class PromiseHolder {
+public:
+  /**
+   * Create a new PromiseHolder (and a new `std::promise<T>`).
+   */
+  explicit PromiseHolder() {
+    _promise = std::make_shared<std::promise<T>>();
+  }
+  
+  /**
+   * Resolve the underlying `std::promise<T>` with `T`.
+   */
+  void resolve(const T& result) const {
+    _promise->set_value(result);
+  }
+  
+  /**
+   * Reject the underlying `std::promise<T>` with the given message.
+   */
+  void reject(const std::string& message) const {
+    try {
+      throw std::runtime_error(message);
+    } catch (...) {
+      _promise->set_exception(std::current_exception());
+    }
+  }
+  
+  /**
+   * Get the `std::future<T>` of the underlying `std::promise<T>`.
+   * This can only be called once.
+   */
+  std::future<T> getFuture() { return _promise->get_future(); }
+  
+private:
+  std::shared_ptr<std::promise<T>> _promise;
+};
+
+// Specialization for `void` (no args to `resolve()`)
+template<>
+class PromiseHolder<void> {
+public:
+  explicit PromiseHolder() {
+    _promise = std::make_shared<std::promise<void>>();
+  }
+  
+  void resolve() const {
+    _promise->set_value();
+  }
+  
+  void reject(const std::string& message) const {
+    try {
+      throw std::runtime_error(message);
+    } catch (...) {
+      _promise->set_exception(std::current_exception());
+    }
+  }
+  
+  std::future<void> getFuture() { return _promise->get_future(); }
+  
+private:
+  std::shared_ptr<std::promise<void>> _promise;
+};
+
+} // namespace margelo::nitro

package/ios/turbomodule/NitroModuleOnLoad.mm

@@ -9,6 +9,11 @@
 #import "RegisterNativeNitroModules.hpp"
 #import <Foundation/Foundation.h>
 
+// just import headers so we have syntax highlighting
+#import "PromiseHolder.hpp"
+#import "ArrayBufferHolder.hpp"
+#import "HybridContext.hpp"
+
 @interface NitroModulesOnLoad : NSObject
 @end
 

package/ios/utils/ClosureWrapper.swift

@@ -0,0 +1,45 @@
+//
+//  ClosureWrapper.swift
+//  NitroModules
+//
+//  Created by Marc Rousavy on 14.08.24.
+//
+
+import Foundation
+
+/**
+ * Wraps a closure in a Swift class.
+ * This can be used to create unmanaged pointers (`void*`) and
+ * passed to C-style function pointers via `void* context` parameters.
+ *
+ * To create a `ClosureWrapper`, use `ClosureWrapper.wrap(...)`.
+ */
+public final class ClosureWrapper {
+  private let closure: () -> Void
+
+  private init(closure: @escaping () -> Void) {
+    self.closure = closure
+  }
+
+  private func invoke() {
+    closure()
+  }
+  
+  /**
+   * Wraps the given Swift closure in a C-style function pointer with `void* context` associated to it.
+   * This way it can be passed to C/C++ and called without worrying about context/binding.
+   */
+  public static func wrap(closure: @escaping () -> Void) -> (@convention(c) (UnsafeMutableRawPointer?) -> Void, UnsafeMutableRawPointer) {
+    // Wrap closure in void*
+    let context = Unmanaged.passRetained(ClosureWrapper(closure: closure)).toOpaque()
+    // Create C-style Function Pointer
+    let cFunc: @convention(c) (UnsafeMutableRawPointer?) -> Void = { context in
+      guard let context else { fatalError("Context was null, even though we created one!") }
+      // Unwrap context from void* to closure again
+      let closure = Unmanaged<ClosureWrapper>.fromOpaque(context).takeRetainedValue()
+      // Call it!
+      closure.invoke()
+    }
+    return (cFunc, context)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Insanely fast native C++, Swift or Kotlin modules with a statically compiled binding layer to JSI.",
   "main": "lib/index",
   "module": "lib/index",

package/ios/core/ClosureWrapper.swift

@@ -1,25 +0,0 @@
-//
-//  ClosureWrapper.swift
-//  NitroModules
-//
-//  Created by Marc Rousavy on 14.08.24.
-//
-
-import Foundation
-
-/**
- * Wraps a closure in a Swift class.
- * This can be used to create unmanaged pointers (`void*`) and
- * passed to C-style function pointers via `void* context` parameters.
- */
-final class ClosureWrapper {
-  let closure: () -> Void
-  
-  init(closure: @escaping () -> Void) {
-    self.closure = closure
-  }
-  
-  func invoke() {
-    closure()
-  }
-}

package/ios/core/HybridContext.cpp

@@ -1,8 +0,0 @@
-//
-//  HybridContext.hpp
-//  NitroModules
-//
-//  Created by Marc Rousavy on 17.07.24.
-//
-
-#include "HybridContext.hpp"

package/ios/core/Promise.cpp

@@ -1,10 +0,0 @@
-//
-//  Promise.cpp
-//  NitroModules
-//
-//  Created by Marc Rousavy on 11.08.24.
-//
-
-#include "Promise.hpp"
-
-namespace margelo::nitro {} // namespace margelo::nitro

package/ios/core/Promise.hpp

@@ -1,43 +0,0 @@
-//
-//  Promise.hpp
-//  NitroModules
-//
-//  Created by Marc Rousavy on 11.08.24.
-//
-
-#pragma once
-
-#include <future>
-#include <memory>
-#include <string>
-
-namespace margelo::nitro {
-
-class Promise {
-public:
-  Promise(const Promise&) = delete;
-  Promise(Promise&&) = delete;
-
-public:
-  void reject(const std::string& message) {
-    // TODO: reject()
-  }
-
-  void resolve(int result) {
-    // TODO: resolve()
-  }
-
-private:
-  explicit Promise() {
-    // TODO: Init? From Future?
-  }
-
-public:
-  static std::shared_ptr<Promise> run(void (*run)(std::shared_ptr<Promise> promise)) {
-    auto promise = std::shared_ptr<Promise>(new Promise());
-    run(promise);
-    return promise;
-  }
-};
-
-} // namespace margelo::nitro

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

@@ -1 +0,0 @@
-{"version":3,"file":"AnyMap.d.ts","sourceRoot":"","sources":["../../src/AnyMap.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,MAAM,GACN,OAAO,GACP,MAAM,GACN,IAAI,GACJ,SAAS,EAAE,GACX;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAA;AAE9B;;;;;;;;GAQG;AACH,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"HybridObject.d.ts","sourceRoot":"","sources":["../../src/HybridObject.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,EAAE,OAAO,GAAG,KAAK,CAAA;IACrB,OAAO,CAAC,EAAE,QAAQ,GAAG,KAAK,CAAA;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,YAAY,CAAC,SAAS,SAAS,YAAY,GAAG,EAAE;IAC/D;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;;;;;;;;;;OAUG;IACH,QAAQ,IAAI,MAAM,CAAA;IAClB;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,KAAK,EAAE,YAAY,CAAC,SAAS,CAAC,GAAG,OAAO,CAAA;CAChD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"ModuleNotFoundError.d.ts","sourceRoot":"","sources":["../../src/ModuleNotFoundError.ts"],"names":[],"mappings":"AAEA,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,kBAAkB,EAAE,OAAO,GAAG,SAAS,CAAA;CAC5C;AA2BD,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,KAAK,CAAC,EAAE,OAAO;CAwD5B"}

package/lib/typescript/NativeNitroModules.d.ts

@@ -1,15 +0,0 @@
-import type { TurboModule } from 'react-native';
-import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
-export interface Spec extends TurboModule {
-    install(): void;
-    createHybridObject(name: string, args?: UnsafeObject): UnsafeObject;
-    hasHybridObject(name: string): boolean;
-    getAllHybridObjectNames(): string[];
-}
-export declare function getNativeNitroModules(): Spec;
-declare global {
-    var __nitroModulesJSICache: {};
-    var __nitroDispatcher: {};
-}
-export declare function isRuntimeAlive(): boolean;
-//# sourceMappingURL=NativeNitroModules.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"NativeNitroModules.d.ts","sourceRoot":"","sources":["../../src/NativeNitroModules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAA;AAG7E,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,OAAO,IAAI,IAAI,CAAA;IACf,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,YAAY,CAAA;IACnE,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;IACtC,uBAAuB,IAAI,MAAM,EAAE,CAAA;CACpC;AAGD,wBAAgB,qBAAqB,IAAI,IAAI,CAc5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,sBAAsB,EAAE,EAAE,CAAA;IAC9B,IAAI,iBAAiB,EAAE,EAAE,CAAA;CAC1B;AAED,wBAAgB,cAAc,YAI7B"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"NativeNitroModules.web.d.ts","sourceRoot":"","sources":["../../src/NativeNitroModules.web.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE/C,MAAM,WAAW,IAAK,SAAQ,WAAW;CAAG;AAE5C,wBAAgB,qBAAqB,IAAI,IAAI,CAI5C"}

package/lib/typescript/NitroModules.d.ts

@@ -1,26 +0,0 @@
-import type { HybridObject } from './HybridObject';
-/**
- * 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;
-};
-//# sourceMappingURL=NitroModules.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"NitroModules.d.ts","sourceRoot":"","sources":["../../src/NitroModules.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AASlD;;GAEG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;;;;OASG;uBACgB,CAAC,SAAS,YAAY,CAAC,GAAG,CAAC,QAAQ,MAAM,GAAG,CAAC;IAKhE;;OAEG;+BACwB,MAAM,EAAE;IAInC;;OAEG;0BACmB,MAAM,GAAG,OAAO;CAIvC,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/index.test.tsx"],"names":[],"mappings":""}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,UAAU,CAAA"}