react-native-nitro-modules 0.16.2 → 0.18.0

package/cpp/jsi/JSIConverter+Promise.hpp

@@ -6,9 +6,6 @@
 
 // Forward declare a few of the common types that might have cyclic includes.
 namespace margelo::nitro {
-class Dispatcher;
-
-class JSPromise;
 
 template <typename T, typename Enable>
 struct JSIConverter;
@@ -16,11 +13,8 @@ struct JSIConverter;
 
 #include "JSIConverter.hpp"
 
-#include "Dispatcher.hpp"
-#include "JSPromise.hpp"
-#include "ThreadPool.hpp"
-#include "TypeInfo.hpp"
-#include <future>
+#include "Promise.hpp"
+#include <exception>
 #include <jsi/jsi.h>
 #include <memory>
 
@@ -28,66 +22,86 @@ namespace margelo::nitro {
 
 using namespace facebook;
 
-// std::future<T> <> Promise<T>
+// Promise<T, std::exception> <> Promise<T>
 template <typename TResult>
-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!");
+struct JSIConverter<std::shared_ptr<Promise<TResult>>> final {
+  static inline std::shared_ptr<Promise<TResult>> fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+    // Create new Promise and prepare onResolved / onRejected callbacks
+    auto promise = Promise<TResult>::create();
+    auto thenCallback = [&]() {
+      if constexpr (std::is_void_v<TResult>) {
+        // void: resolve()
+        return JSIConverter<std::function<void(std::monostate)>>::toJSI(runtime, [=](std::monostate) { promise->resolve(); });
+      } else {
+        // T: resolve(T)
+        return JSIConverter<std::function<void(TResult)>>::toJSI(runtime, [=](const TResult& result) { promise->resolve(result); });
+      }
+    }();
+    auto catchCallback = JSIConverter<std::function<void(std::exception_ptr)>>::toJSI(
+        runtime, [=](const std::exception_ptr& exception) { promise->reject(exception); });
+
+    // Chain .then listeners on JS Promise (onResolved and onRejected)
+    jsi::Object jsPromise = value.asObject(runtime);
+    jsi::Function thenFn = jsPromise.getPropertyAsFunction(runtime, "then");
+    thenFn.callWithThis(runtime, jsPromise, thenCallback, catchCallback);
+
+    return promise;
   }
 
-  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);
-    std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;
-
-    return JSPromise::createPromise(runtime, [sharedFuture, weakDispatcher](jsi::Runtime& runtime, std::shared_ptr<JSPromise> promise) {
-      // Spawn new async thread to synchronously wait for the `future<T>` to complete
-      std::shared_ptr<ThreadPool> pool = ThreadPool::getSharedPool();
-      pool->run([promise, &runtime, weakDispatcher, sharedFuture]() {
-        // synchronously wait until the `future<T>` completes. we are running on a background task here.
-        sharedFuture->wait();
-
-        // the async function completed successfully, get a JS Dispatcher so we can resolve on JS Thread
-        std::shared_ptr<Dispatcher> dispatcher = weakDispatcher.lock();
-        if (!dispatcher) {
-          Logger::log(LogLevel::Error, "JSIConverter",
-                      "Tried resolving Promise on JS Thread, but the `Dispatcher` has already been destroyed!");
-          return;
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::shared_ptr<Promise<TResult>>& promise) {
+    if (promise->isPending()) {
+      // Get Promise ctor from global
+      jsi::Function promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
+      jsi::HostFunctionType executor = [promise](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+                                                 size_t count) -> jsi::Value {
+        // Add resolver listener
+        if constexpr (std::is_void_v<TResult>) {
+          // It's resolving to void.
+          auto resolver = JSIConverter<std::function<void()>>::fromJSI(runtime, arguments[0]);
+          promise->addOnResolvedListener(std::move(resolver));
+        } else {
+          // It's a type.
+          auto resolver = JSIConverter<std::function<void(TResult)>>::fromJSI(runtime, arguments[0]);
+          promise->addOnResolvedListener(std::move(resolver));
         }
-
-        dispatcher->runAsync([&runtime, promise, sharedFuture]() mutable {
-          try {
-            if constexpr (std::is_void_v<TResult>) {
-              // it's returning void, just return undefined to JS
-              sharedFuture->get();
-              promise->resolve(runtime, jsi::Value::undefined());
-            } else {
-              // it's returning a custom type, convert it to a jsi::Value
-              TResult result = sharedFuture->get();
-              jsi::Value jsResult = JSIConverter<TResult>::toJSI(runtime, std::forward<TResult>(result));
-              promise->resolve(runtime, std::move(jsResult));
-            }
-          } catch (const std::exception& exception) {
-            // the async function threw an error, reject the promise on JS Thread
-            std::string what = exception.what();
-            promise->reject(runtime, what);
-          } catch (...) {
-            // the async function threw a non-std error, try getting it
-            std::string name = TypeInfo::getCurrentExceptionName();
-            promise->reject(runtime, "Unknown non-std exception: " + name);
-          }
-
-          // This lambda owns the promise shared pointer, and we need to call its
-          // destructor on the correct thread here - otherwise it might be called
-          // from the waiterThread.
-          promise = nullptr;
-        });
-      });
-    });
+        // Add rejecter listener
+        auto rejecter = JSIConverter<std::function<void(std::exception_ptr)>>::fromJSI(runtime, arguments[1]);
+        promise->addOnRejectedListener(std::move(rejecter));
+
+        return jsi::Value::undefined();
+      };
+      // Call `Promise` constructor (aka create promise), and pass `executor` function
+      return promiseCtor.callAsConstructor(
+          runtime, jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, "executor"), 2, executor));
+    } else if (promise->isResolved()) {
+      // Promise is already resolved - just return immediately
+      jsi::Object promiseObject = runtime.global().getPropertyAsObject(runtime, "Promise");
+      jsi::Function createResolvedPromise = promiseObject.getPropertyAsFunction(runtime, "resolve");
+      if constexpr (std::is_void_v<TResult>) {
+        // It's resolving to void.
+        return createResolvedPromise.call(runtime);
+      } else {
+        // It's resolving to a type.
+        jsi::Value result = JSIConverter<TResult>::toJSI(runtime, promise->getResult());
+        return createResolvedPromise.call(runtime, std::move(result));
+      }
+    } else if (promise->isRejected()) {
+      // Promise is already rejected - just return immediately
+      jsi::Object promiseObject = runtime.global().getPropertyAsObject(runtime, "Promise");
+      jsi::Function createRejectedPromise = promiseObject.getPropertyAsFunction(runtime, "reject");
+      jsi::Value error = JSIConverter<std::exception_ptr>::toJSI(runtime, promise->getError());
+      return createRejectedPromise.call(runtime, std::move(error));
+    } else {
+      throw std::runtime_error("Promise has invalid state!");
+    }
   }
 
-  static inline bool canConvert(jsi::Runtime&, const jsi::Value&) {
-    throw std::runtime_error("jsi::Value of type Promise cannot be converted to std::future yet!");
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (!value.isObject()) {
+      return false;
+    }
+    jsi::Object object = value.getObject(runtime);
+    return object.hasProperty(runtime, "then");
   }
 };
 

package/cpp/jsi/JSIConverter.hpp

@@ -183,7 +183,9 @@ struct JSIConverter<std::string> final {
 
 #include "JSIConverter+AnyMap.hpp"
 #include "JSIConverter+ArrayBuffer.hpp"
+#include "JSIConverter+Exception.hpp"
 #include "JSIConverter+Function.hpp"
+#include "JSIConverter+Future.hpp"
 #include "JSIConverter+HostObject.hpp"
 #include "JSIConverter+HybridObject.hpp"
 #include "JSIConverter+Optional.hpp"

package/cpp/platform/ThreadUtils.hpp

@@ -5,6 +5,8 @@
 //  Created by Marc Rousavy on 14.07.24.
 //
 
+#pragma once
+
 #include <string>
 
 namespace margelo::nitro {

package/cpp/prototype/HybridObjectPrototype.cpp

@@ -8,6 +8,7 @@
 #include "HybridObjectPrototype.hpp"
 #include "NitroDefines.hpp"
 #include "NitroLogger.hpp"
+#include "TypeInfo.hpp"
 
 namespace margelo::nitro {
 

package/cpp/templates/IsSharedPtrTo.hpp

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include <jsi/jsi.h>
 #include <type_traits>
 
 namespace margelo::nitro {

package/cpp/threading/ThreadPool.cpp

@@ -11,38 +11,58 @@
 
 namespace margelo::nitro {
 
-ThreadPool::ThreadPool(const char* name, size_t numThreads) : _isAlive(true), _name(name) {
-  Logger::log(LogLevel::Info, TAG, "Creating ThreadPool \"%s\" with %i threads...", name, numThreads);
+ThreadPool::ThreadPool(const char* name, size_t initialThreadsCount, size_t maxThreadsCount)
+    : _isAlive(true), _threadCountLimit(maxThreadsCount), _name(name) {
+  Logger::log(LogLevel::Info, TAG, "Creating ThreadPool \"%s\" with %i initial threads (max: %i)...", name, initialThreadsCount,
+              maxThreadsCount);
 
-  for (size_t i = 0; i < numThreads; ++i) {
-    std::string threadName = std::string(name) + "-" + std::to_string(i + 1);
-    _workers.emplace_back([this, threadName] {
-      // Set the Thread's name
-      ThreadUtils::setThreadName(threadName);
+  for (size_t i = 0; i < initialThreadsCount; i++) {
+    addThread();
+  }
+}
+
+void ThreadPool::addThread() {
+  std::unique_lock<std::mutex> lock(_queueMutex);
+  if (!_isAlive) {
+    return;
+  }
+
+  size_t i = ++_threadCount;
+  Logger::log(LogLevel::Info, TAG, "Adding Thread %i to ThreadPool \"%s\"...", i, _name);
+
+  std::string threadName = std::string(_name) + "-" + std::to_string(i);
+  _workers.emplace_back([this, threadName] {
+    // Set the Thread's name
+    ThreadUtils::setThreadName(threadName);
 
-      // Start the run-loop
-      while (true) {
-        std::function<void()> task;
-        {
-          // Lock on the mutex so only one Worker receives the condition signal at a time
-          std::unique_lock<std::mutex> lock(_queueMutex);
-          this->_condition.wait(lock, [this] { return !_isAlive || !_tasks.empty(); });
-          if (!_isAlive && _tasks.empty()) {
-            // ThreadPool is dead - stop run-loop.
-            return;
-          }
-          // Schedule the oldest task
-          task = std::move(_tasks.front());
-          _tasks.pop();
+    // Start the run-loop
+    while (true) {
+      std::function<void()> task;
+      {
+        // Lock on the mutex so only one Worker receives the condition signal at a time
+        std::unique_lock<std::mutex> lock(_queueMutex);
+        this->_condition.wait(lock, [this] { return !_isAlive || !_tasks.empty(); });
+        if (!_isAlive && _tasks.empty()) {
+          // ThreadPool is dead - stop run-loop.
+          return;
         }
-        // Run it (outside of the mutex so others can run in parallel)
-        task();
+        // Schedule the oldest task
+        task = std::move(_tasks.front());
+        _tasks.pop();
       }
-    });
-  }
+      // Run it (outside of the mutex so others can run in parallel)
+      task();
+    }
+  });
+  _condition.notify_all();
 }
 
 void ThreadPool::run(std::function<void()>&& task) {
+  // If there are tasks still waiting to be finished, just start a new Thread.
+  if (!_tasks.empty() && _threadCount < _threadCountLimit) {
+    addThread();
+  }
+  // New scope because of RAII lock
   {
     // lock on the mutex - we want to emplace the task back in the queue
     std::unique_lock<std::mutex> lock(_queueMutex);
@@ -71,13 +91,8 @@ ThreadPool::~ThreadPool() {
   }
 }
 
-std::shared_ptr<ThreadPool> ThreadPool::getSharedPool() {
-  static std::shared_ptr<ThreadPool> shared;
-  if (shared == nullptr) {
-    int availableThreads = std::thread::hardware_concurrency();
-    auto numThreads = std::min(availableThreads, 3);
-    shared = std::make_shared<ThreadPool>("nitro-thread", numThreads);
-  }
+ThreadPool& ThreadPool::shared() {
+  static ThreadPool shared("nitro-thread", 3, 10);
   return shared;
 }
 

package/cpp/threading/ThreadPool.hpp

@@ -22,10 +22,13 @@ namespace margelo::nitro {
 class ThreadPool final {
 public:
   /**
-   * Create a new ThreadPool with the given number of fixed workers/threads.
+   * Create a new ThreadPool with the given number of minimum workers/threads.
+   * The Thread Pool can expand on the fly if it is busy.
    */
-  explicit ThreadPool(const char* const name, size_t numThreads);
+  explicit ThreadPool(const char* const name, size_t initialThreadsCount, size_t maxThreadsCount);
   ~ThreadPool();
+  ThreadPool(const ThreadPool&) = delete;
+  ThreadPool(ThreadPool&&) = delete;
 
   /**
    * Schedules the given task asynchronously on the ThreadPool.
@@ -33,12 +36,19 @@ public:
    */
   void run(std::function<void()>&& task);
 
+private:
+  /**
+   * Adds a new Thread to the current Thread Pool.
+   * This grows the size by one, and potentially starts work sooner if other Threads are busy.
+   */
+  void addThread();
+
 public:
   /**
    * Get a static singleton instance - a shared ThreadPool.
    * The shared ThreadPool has 3 threads.
    */
-  static std::shared_ptr<ThreadPool> getSharedPool();
+  static ThreadPool& shared();
 
 private:
   std::vector<std::thread> _workers;
@@ -46,6 +56,8 @@ private:
   std::mutex _queueMutex;
   std::condition_variable _condition;
   std::atomic<bool> _isAlive;
+  std::atomic<size_t> _threadCount;
+  size_t _threadCountLimit;
   const char* _name;
   static constexpr auto TAG = "ThreadPool";
 };

package/cpp/utils/AssertPromiseState.hpp

@@ -0,0 +1,34 @@
+//
+//  AssertPromiseState.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 20.11.24.
+//
+
+#pragma once
+
+namespace margelo::nitro {
+template <typename TResult>
+class Promise;
+} // namespace margelo::nitro
+
+#include "Promise.hpp"
+#include "TypeInfo.hpp"
+#include <exception>
+#include <string>
+
+namespace margelo::nitro {
+
+enum PromiseTask { WANTS_TO_RESOLVE, WANTS_TO_REJECT };
+
+template <typename TResult>
+void assertPromiseState(Promise<TResult>& promise, PromiseTask task) {
+  if (!promise.isPending()) [[unlikely]] {
+    std::string taskString = task == WANTS_TO_RESOLVE ? "resolve" : "reject";
+    std::string state = promise.isResolved() ? "resolved" : "rejected";
+    throw std::runtime_error("Cannot " + taskString + " Promise<" + TypeInfo::getFriendlyTypename<TResult>() + "> - it is already " +
+                             state + "!");
+  }
+}
+
+} // namespace margelo::nitro

package/cpp/utils/BorrowingReference.hpp

@@ -111,7 +111,7 @@ private:
   bool* _isDeleted;
   std::atomic_size_t* _strongRefCount;
   std::atomic_size_t* _weakRefCount;
-  std::mutex* _mutex;
+  std::recursive_mutex* _mutex;
 };
 
 } // namespace margelo::nitro

package/cpp/utils/OwningReference.hpp

@@ -34,7 +34,7 @@ public:
 
   explicit OwningReference(T* value)
       : _value(value), _isDeleted(new bool(false)), _strongRefCount(new std::atomic_size_t(1)), _weakRefCount(new std::atomic_size_t(0)),
-        _mutex(new std::mutex()) {}
+        _mutex(new std::recursive_mutex()) {}
 
   OwningReference(const OwningReference& ref)
       : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
@@ -229,7 +229,7 @@ private:
   bool* _isDeleted;
   std::atomic_size_t* _strongRefCount;
   std::atomic_size_t* _weakRefCount;
-  std::mutex* _mutex;
+  std::recursive_mutex* _mutex;
 };
 
 } // namespace margelo::nitro

package/cpp/utils/TypeInfo.hpp

@@ -24,17 +24,6 @@ struct TypeInfo final {
 public:
   TypeInfo() = delete;
 
-  /**
-   * Get the name of the currently thrown exception
-   */
-  static inline const char* getCurrentExceptionName() {
-#if __has_include(<cxxabi.h>)
-    return __cxxabiv1::__cxa_current_exception_type()->name();
-#else
-    return "<unknown>";
-#endif
-  }
-
   static inline std::string replaceRegex(const std::string& original, const std::string& pattern, const std::string& replacement) {
     std::regex re(pattern);
     return std::regex_replace(original, re, replacement);
@@ -112,6 +101,18 @@ public:
     std::string string = stream.str();
     return string.substr(0, string.length() - 2);
   }
+
+  /**
+   * Get the name of the currently thrown exception
+   */
+  static inline std::string getCurrentExceptionName() {
+#if __has_include(<cxxabi.h>)
+    std::string name = __cxxabiv1::__cxa_current_exception_type()->name();
+    return demangleName(name);
+#else
+    return "<unknown>";
+#endif
+  }
 };
 
 } // namespace margelo::nitro

package/ios/core/RuntimeError.swift

@@ -12,6 +12,31 @@ import Foundation
  *
  * Throw this error in Nitro Modules to provide clear and concise error messages to JS.
  */
-public enum RuntimeError: Error {
+@frozen
+public enum RuntimeError: Error, CustomStringConvertible {
   case error(withMessage: String)
+
+  public var description: String {
+    switch self {
+      case .error(let message): return message
+    }
+  }
+
+  /**
+   * Creates a new `RuntimeError` from the given C++ `std::exception`.
+   */
+  public static func from(cppError: std.exception_ptr) -> RuntimeError {
+    let message = margelo.nitro.get_exception_message(cppError)
+    return .error(withMessage: String(message))
+  }
+}
+
+public extension Error {
+  /**
+   * Converts this `Error` to a C++ `std::exception`.
+   */
+  func toCpp() -> std.exception_ptr {
+    let message = String(describing: self)
+    return margelo.nitro.make_exception(std.string(message))
+  }
 }

package/ios/turbomodule/NativeNitroModules+OldArch.mm

@@ -57,7 +57,7 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
     // 5. Install Nitro
     nitro::install(*runtime, dispatcher);
     return nil;
-  } catch (std::exception& error) {
+  } catch (const std::exception& error) {
     // ?. Any C++ error occurred (probably in nitro::install()?)
     return [NSString stringWithCString:error.what() encoding:kCFStringEncodingUTF8];
   } catch (...) {

package/ios/utils/RuntimeError.hpp

@@ -0,0 +1,30 @@
+//
+//  RuntimeError.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 19.11.24.
+//
+
+#pragma once
+
+#include <exception>
+#include <string>
+
+namespace margelo::nitro {
+
+static inline std::exception_ptr make_exception(const std::string& message) {
+  return std::make_exception_ptr(std::runtime_error(message));
+}
+
+static inline std::string get_exception_message(const std::exception_ptr& exception) {
+  try {
+    std::rethrow_exception(exception);
+  } catch (const std::exception& error) {
+    return error.what();
+  } catch (...) {
+    std::string errorName = TypeInfo::getCurrentExceptionName();
+    return "Unknown " + errorName + " exception";
+  }
+}
+
+} // namespace margelo::nitro

package/ios/utils/SwiftClosure.hpp

@@ -55,7 +55,11 @@ public:
   /**
    * Gets the underlying `std::function`.
    */
-  const std::function<void()>& getFunction() {
+  const std::function<void()>& getFunction() const {
+    return _function;
+  }
+
+  std::function<void()> getFunctionCopy() const {
     return _function;
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.16.2",
+  "version": "0.18.0",
   "description": "Insanely fast native C++, Swift or Kotlin modules with a statically compiled binding layer to JSI.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -28,6 +28,8 @@
     "ios",
     "android",
     "visionOS",
+    "tvOS",
+    "macOS",
     "cpp",
     "framework",
     "react",
@@ -70,7 +72,7 @@
     "jest": "*",
     "react": "*",
     "react-native": "*",
-    "react-native-builder-bob": "^0.31.0"
+    "react-native-builder-bob": "^0.33.1"
   },
   "peerDependencies": {
     "react": "*",

package/cpp/jsi/JSPromise.cpp

@@ -1,58 +0,0 @@
-#include "JSPromise.hpp"
-#include "JSICache.hpp"
-#include "NitroLogger.hpp"
-#include <jsi/jsi.h>
-
-namespace margelo::nitro {
-
-using namespace facebook;
-
-JSPromise::JSPromise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter) {
-  auto functionCache = JSICache::getOrCreateCache(runtime);
-  _resolver = functionCache.makeShared(std::move(resolver));
-  _rejecter = functionCache.makeShared(std::move(rejecter));
-}
-
-jsi::Value JSPromise::createPromise(jsi::Runtime& runtime, RunPromise&& run) {
-  // Get Promise ctor from global
-  auto promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
-
-  auto promiseCallback = jsi::Function::createFromHostFunction(
-      runtime, jsi::PropNameID::forUtf8(runtime, "PromiseCallback"), 2,
-      [run = std::move(run)](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments, size_t count) -> jsi::Value {
-        // Get resolver and rejecter
-        auto resolver = arguments[0].getObject(runtime).getFunction(runtime);
-        auto rejecter = arguments[1].getObject(runtime).getFunction(runtime);
-        // Create `Promise` type that wraps the JSI callbacks
-        auto promise = std::make_shared<JSPromise>(runtime, std::move(resolver), std::move(rejecter));
-        // Call `run` callback
-        run(runtime, promise);
-
-        return jsi::Value::undefined();
-      });
-
-  return promiseCtor.callAsConstructor(runtime, promiseCallback);
-}
-
-void JSPromise::resolve(jsi::Runtime& runtime, jsi::Value&& result) {
-  OwningLock<jsi::Function> lock = _resolver.lock();
-
-  if (!_resolver) {
-    Logger::log(LogLevel::Error, TAG, "Promise resolver function has already been deleted! Ignoring call..");
-    return;
-  }
-  _resolver->call(runtime, std::move(result));
-}
-
-void JSPromise::reject(jsi::Runtime& runtime, std::string message) {
-  OwningLock<jsi::Function> lock = _rejecter.lock();
-
-  if (!_rejecter) {
-    Logger::log(LogLevel::Error, TAG, "Promise rejecter function has already been deleted! Ignoring call..");
-    return;
-  }
-  jsi::JSError error(runtime, message);
-  _rejecter->call(runtime, error.value());
-}
-
-} // namespace margelo::nitro