react-native-nitro-modules 0.16.2 → 0.17.0

package/cpp/core/Promise.hpp

@@ -0,0 +1,388 @@
+//
+// Created by Marc Rousavy on 18.11.24.
+//
+
+#pragma once
+
+#include "ThreadPool.hpp"
+#include "TypeInfo.hpp"
+#include <exception>
+#include <future>
+#include <jsi/jsi.h>
+#include <memory>
+#include <mutex>
+#include <variant>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+template <typename TResult, typename TError = std::exception>
+class Promise final {
+public:
+  using OnResolvedFunc = std::function<void(const TResult&)>;
+  using OnRejectedFunc = std::function<void(const TError&)>;
+
+public:
+  // Promise cannot be deleted.
+  Promise(const Promise&) = delete;
+  // Promise can be moved.
+  Promise(Promise&&) = default;
+
+private:
+  Promise() {
+    _mutex = std::make_unique<std::mutex>();
+  }
+
+public:
+  /**
+   * Creates a new pending Promise that has to be resolved
+   * or rejected with `resolve(..)` or `reject(..)`.
+   */
+  static std::shared_ptr<Promise> create() {
+    return std::shared_ptr<Promise>(new Promise());
+  }
+
+  /**
+   * Creates a Promise that runs the given function `run` on a separate Thread pool.
+   */
+  static std::shared_ptr<Promise> async(std::function<TResult()>&& run) {
+    auto promise = create();
+    ThreadPool::shared().run([run = std::move(run), promise]() {
+      try {
+        // Run the code, then resolve.
+        TResult result = run();
+        promise->resolve(std::move(result));
+      } catch (const TError& exception) {
+        // It threw an std::exception.
+        promise->reject(exception);
+      } catch (...) {
+        // It threw a different error.
+        std::string name = TypeInfo::getCurrentExceptionName();
+        promise->reject(std::runtime_error("Unknown non-std error! Name: " + name));
+      }
+    });
+    return promise;
+  }
+
+  /**
+   * Creates a Promise and awaits the given future on a background Thread.
+   * Once the future resolves or rejects, the Promise resolves or rejects.
+   */
+  static std::shared_ptr<Promise> awaitFuture(std::future<TResult>&& future) {
+    auto sharedFuture = std::make_shared<std::future<TResult>>(std::move(future));
+    return async([sharedFuture = std::move(sharedFuture)]() { return sharedFuture->get(); });
+  }
+
+  /**
+   * Creates an immediately resolved Promise.
+   */
+  static std::shared_ptr<Promise> resolved(TResult&& result) {
+    auto promise = create();
+    promise->resolve(std::move(result));
+    return promise;
+  }
+  /**
+   * Creates an immediately rejected Promise.
+   */
+  static std::shared_ptr<Promise> rejected(TError&& error) {
+    auto promise = create();
+    promise->reject(std::move(error));
+    return promise;
+  }
+
+public:
+  /**
+   * Resolves this Promise with the given result, and calls any pending listeners.
+   */
+  void resolve(TResult&& result) {
+    std::unique_lock lock(*_mutex);
+    _result = std::move(result);
+    for (const auto& onResolved : _onResolvedListeners) {
+      onResolved(std::get<TResult>(_result));
+    }
+  }
+  void resolve(const TResult& result) {
+    std::unique_lock lock(*_mutex);
+    _result = result;
+    for (const auto& onResolved : _onResolvedListeners) {
+      onResolved(std::get<TResult>(_result));
+    }
+  }
+  /**
+   * Rejects this Promise with the given error, and calls any pending listeners.
+   */
+  void reject(TError&& exception) {
+    std::unique_lock lock(*_mutex);
+    _result = std::move(exception);
+    for (const auto& onRejected : _onRejectedListeners) {
+      onRejected(std::get<TError>(_result));
+    }
+  }
+  void reject(const TError& exception) {
+    std::unique_lock lock(*_mutex);
+    _result = exception;
+    for (const auto& onRejected : _onRejectedListeners) {
+      onRejected(std::get<TError>(_result));
+    }
+  }
+
+public:
+  /**
+   * Add a listener that will be called when the Promise gets resolved.
+   * If the Promise is already resolved, the listener will be immediately called.
+   */
+  void addOnResolvedListener(OnResolvedFunc&& onResolved) {
+    std::unique_lock lock(*_mutex);
+    if (std::holds_alternative<TResult>(_result)) {
+      // Promise is already resolved! Call the callback immediately
+      onResolved(std::get<TResult>(_result));
+    } else {
+      // Promise is not yet resolved, put the listener in our queue.
+      _onResolvedListeners.push_back(std::move(onResolved));
+    }
+  }
+  void addOnResolvedListener(const OnResolvedFunc& onResolved) {
+    std::unique_lock lock(*_mutex);
+    if (std::holds_alternative<TResult>(_result)) {
+      // Promise is already resolved! Call the callback immediately
+      onResolved(std::get<TResult>(_result));
+    } else {
+      // Promise is not yet resolved, put the listener in our queue.
+      _onResolvedListeners.push_back(onResolved);
+    }
+  }
+  void addOnResolvedListenerCopy(const std::function<void(TResult)>& onResolved) {
+    std::unique_lock lock(*_mutex);
+    if (std::holds_alternative<TResult>(_result)) {
+      // Promise is already resolved! Call the callback immediately
+      onResolved(std::get<TResult>(_result));
+    } else {
+      // Promise is not yet resolved, put the listener in our queue.
+      _onResolvedListeners.push_back(onResolved);
+    }
+  }
+
+  /**
+   * Add a listener that will be called when the Promise gets rejected.
+   * If the Promise is already rejected, the listener will be immediately called.
+   */
+  void addOnRejectedListener(OnRejectedFunc&& onRejected) {
+    std::unique_lock lock(*_mutex);
+    if (std::holds_alternative<TError>(_result)) {
+      // Promise is already rejected! Call the callback immediately
+      onRejected(std::get<TError>(_result));
+    } else {
+      // Promise is not yet rejected, put the listener in our queue.
+      _onRejectedListeners.push_back(std::move(onRejected));
+    }
+  }
+  void addOnRejectedListener(const OnRejectedFunc& onRejected) {
+    std::unique_lock lock(*_mutex);
+    if (std::holds_alternative<TError>(_result)) {
+      // Promise is already rejected! Call the callback immediately
+      onRejected(std::get<TError>(_result));
+    } else {
+      // Promise is not yet rejected, put the listener in our queue.
+      _onRejectedListeners.push_back(onRejected);
+    }
+  }
+
+public:
+  /**
+   * Get the result of the Promise if it has been resolved.
+   * If the Promise is not resolved, this will throw.
+   */
+  inline const TResult& getResult() {
+    if (!isResolved()) {
+      throw std::runtime_error("Cannot get result when Promise is not yet resolved!");
+    }
+    return std::get<TResult>(_result);
+  }
+  /**
+   * Get the error of the Promise if it has been rejected.
+   * If the Promise is not rejected, this will throw.
+   */
+  inline const TError& getError() {
+    if (!isRejected()) {
+      throw std::runtime_error("Cannot get error when Promise is not yet rejected!");
+    }
+    return std::get<TError>(_result);
+  }
+
+public:
+  /**
+   * Gets whether this Promise has been successfully resolved with a result, or not.
+   */
+  [[nodiscard]]
+  inline bool isResolved() const noexcept {
+    return std::holds_alternative<TResult>(_result);
+  }
+  /**
+   * Gets whether this Promise has been rejected with an error, or not.
+   */
+  [[nodiscard]]
+  inline bool isRejected() const noexcept {
+    return std::holds_alternative<TError>(_result);
+  }
+  /**
+   * Gets whether this Promise has not yet been resolved nor rejected.
+   */
+  [[nodiscard]]
+  inline bool isPending() const noexcept {
+    return std::holds_alternative<std::monostate>(_result);
+  }
+
+private:
+  std::variant<std::monostate, TResult, TError> _result;
+  std::vector<OnResolvedFunc> _onResolvedListeners;
+  std::vector<OnRejectedFunc> _onRejectedListeners;
+  std::unique_ptr<std::mutex> _mutex;
+};
+
+// Specialization for void
+template <typename TError>
+class Promise<void, TError> final {
+public:
+  using OnResolvedFunc = std::function<void()>;
+  using OnRejectedFunc = std::function<void(const TError&)>;
+
+public:
+  Promise(const Promise&) = delete;
+  Promise(Promise&&) = default;
+
+private:
+  Promise() {
+    _mutex = std::make_unique<std::mutex>();
+  }
+
+public:
+  static std::shared_ptr<Promise> create() {
+    return std::shared_ptr<Promise>(new Promise());
+  }
+
+  static std::shared_ptr<Promise> async(std::function<void()>&& run) {
+    auto promise = create();
+    ThreadPool::shared().run([run = std::move(run), promise]() {
+      try {
+        // Run the code, then resolve.
+        run();
+        promise->resolve();
+      } catch (const TError& exception) {
+        // It threw an std::exception.
+        promise->reject(exception);
+      } catch (...) {
+        // It threw a different error.
+        std::string name = TypeInfo::getCurrentExceptionName();
+        promise->reject(std::runtime_error("Unknown non-std error! Name: " + name));
+      }
+    });
+    return promise;
+  }
+
+  static std::shared_ptr<Promise> awaitFuture(std::future<void>&& future) {
+    auto sharedFuture = std::make_shared<std::future<void>>(std::move(future));
+    return async([sharedFuture = std::move(sharedFuture)]() { sharedFuture->get(); });
+  }
+
+  static std::shared_ptr<Promise> resolved() {
+    auto promise = create();
+    promise->resolve();
+    return promise;
+  }
+  static std::shared_ptr<Promise> rejected(TError&& error) {
+    auto promise = create();
+    promise->reject(std::move(error));
+    return promise;
+  }
+
+public:
+  void resolve() {
+    std::unique_lock lock(*_mutex);
+    _isResolved = true;
+    for (const auto& onResolved : _onResolvedListeners) {
+      onResolved();
+    }
+  }
+  void reject(TError&& exception) {
+    std::unique_lock lock(*_mutex);
+    _error = std::move(exception);
+    for (const auto& onRejected : _onRejectedListeners) {
+      onRejected(_error.value());
+    }
+  }
+  void reject(const TError& exception) {
+    std::unique_lock lock(*_mutex);
+    _error = exception;
+    for (const auto& onRejected : _onRejectedListeners) {
+      onRejected(_error.value());
+    }
+  }
+
+public:
+  void addOnResolvedListener(OnResolvedFunc&& onResolved) {
+    std::unique_lock lock(*_mutex);
+    if (_isResolved) {
+      onResolved();
+    } else {
+      _onResolvedListeners.push_back(std::move(onResolved));
+    }
+  }
+  void addOnResolvedListener(const OnResolvedFunc& onResolved) {
+    std::unique_lock lock(*_mutex);
+    if (_isResolved) {
+      onResolved();
+    } else {
+      _onResolvedListeners.push_back(onResolved);
+    }
+  }
+  void addOnRejectedListener(OnRejectedFunc&& onRejected) {
+    std::unique_lock lock(*_mutex);
+    if (_error.has_value()) {
+      onRejected(_error.value());
+    } else {
+      // Promise is not yet rejected, put the listener in our queue.
+      _onRejectedListeners.push_back(std::move(onRejected));
+    }
+  }
+  void addOnRejectedListener(const OnRejectedFunc& onRejected) {
+    std::unique_lock lock(*_mutex);
+    if (_error.has_value()) {
+      onRejected(_error.value());
+    } else {
+      // Promise is not yet rejected, put the listener in our queue.
+      _onRejectedListeners.push_back(onRejected);
+    }
+  }
+
+public:
+  inline const TError& getError() {
+    if (!isRejected()) {
+      throw std::runtime_error("Cannot get error when Promise is not yet rejected!");
+    }
+    return _error.value();
+  }
+
+public:
+  [[nodiscard]]
+  inline bool isResolved() const noexcept {
+    return _isResolved;
+  }
+  [[nodiscard]]
+  inline bool isRejected() const noexcept {
+    return _error.has_value();
+  }
+  [[nodiscard]]
+  inline bool isPending() const noexcept {
+    return !isResolved() && !isRejected();
+  }
+
+private:
+  std::unique_ptr<std::mutex> _mutex;
+  bool _isResolved = false;
+  std::optional<TError> _error;
+  std::vector<OnResolvedFunc> _onResolvedListeners;
+  std::vector<OnRejectedFunc> _onRejectedListeners;
+};
+
+} // namespace margelo::nitro

package/cpp/jsi/JSIConverter+Exception.hpp

@@ -0,0 +1,44 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+// Forward declare a few of the common types that might have cyclic includes.
+namespace margelo::nitro {
+template <typename T, typename Enable>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include "JSIConverter.hpp"
+
+#include <exception>
+#include <jsi/jsi.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// std::exception <> Error
+template <>
+struct JSIConverter<std::exception> final {
+  static inline std::exception fromJSI(jsi::Runtime& runtime, const jsi::Value& error) {
+    jsi::Object object = error.asObject(runtime);
+    std::string name = object.getProperty(runtime, "name").asString(runtime).utf8(runtime);
+    std::string message = object.getProperty(runtime, "message").asString(runtime).utf8(runtime);
+    return std::runtime_error(name + ": " + message);
+  }
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::exception& exception) {
+    jsi::JSError error(runtime, exception.what());
+    return jsi::Value(runtime, error.value());
+  }
+  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, "name") && object.hasProperty(runtime, "message");
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/jsi/JSIConverter+Future.hpp

@@ -0,0 +1,45 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+// Forward declare a few of the common types that might have cyclic includes.
+namespace margelo::nitro {
+
+template <typename T, typename Enable>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include "JSIConverter.hpp"
+
+#include "Promise.hpp"
+#include <future>
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// std::future<T> <> Promise<T>
+template <typename TResult>
+struct JSIConverter<std::future<TResult>> final {
+  [[deprecated("Use JSIConverter<std::shared_ptr<Promise<T>>> instead.")]]
+  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!");
+  }
+
+  [[deprecated("Use JSIConverter<std::shared_ptr<Promise<T>>> instead.")]]
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, std::future<TResult>&& arg) {
+    auto promise = Promise<TResult>::awaitFuture(std::move(arg));
+    return JSIConverter<std::shared_ptr<Promise<TResult>>>::toJSI(runtime, promise);
+  }
+
+  [[deprecated("Use JSIConverter<std::shared_ptr<Promise<T>>> instead.")]]
+  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!");
+  }
+};
+
+} // namespace margelo::nitro

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)>>::toJSI(
+        runtime, [=](const std::exception& 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)>>::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>::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/prototype/HybridObjectPrototype.cpp

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