react-native-wgpu 0.1.0

package/cpp/jsi/RNFJSIConverter.h

@@ -0,0 +1,412 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+#include "RNFEnumMapper.h"
+#include "RNFHybridObject.h"
+#include "RNFJSIHelper.h"
+#include "RNFPromise.h"
+#include "RNFWorkletRuntimeRegistry.h"
+#include <jsi/jsi.h>
+#include <memory>
+#include <array>
+#include <future>
+#include <vector>
+#include <string>
+#include <utility>
+#include <type_traits>
+#include <unordered_map>
+
+#if __has_include(<cxxabi.h>)
+#include <cxxabi.h>
+#endif
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+// Unknown type (error)
+template <typename ArgType, typename Enable = void> struct JSIConverter {
+  static ArgType fromJSI(jsi::Runtime&, const jsi::Value&, bool outOfBound) {
+    static_assert(always_false<ArgType>::value, "This type is not supported by the JSIConverter!");
+    return ArgType();
+  }
+  static jsi::Value toJSI(jsi::Runtime&, ArgType) {
+    static_assert(always_false<ArgType>::value, "This type is not supported by the JSIConverter!");
+    return jsi::Value::undefined();
+  }
+
+private:
+  template <typename> struct always_false : std::false_type {};
+};
+
+// int <> number
+template <> struct JSIConverter<int> {
+  static int fromJSI(jsi::Runtime&, const jsi::Value& arg, bool outOfBound) {
+    return static_cast<int>(arg.asNumber());
+  }
+  static jsi::Value toJSI(jsi::Runtime&, int arg) {
+    return jsi::Value(arg);
+  }
+};
+
+// double <> number
+template <> struct JSIConverter<double> {
+  static double fromJSI(jsi::Runtime&, const jsi::Value& arg, bool outOfBound) {
+    return arg.asNumber();
+  }
+  static jsi::Value toJSI(jsi::Runtime&, double arg) {
+    return jsi::Value(arg);
+  }
+};
+
+// float <> number
+template <> struct JSIConverter<float> {
+  static float fromJSI(jsi::Runtime&, const jsi::Value& arg, bool outOfBound) {
+    return static_cast<float>(arg.asNumber());
+  }
+  static jsi::Value toJSI(jsi::Runtime&, float arg) {
+    return jsi::Value(static_cast<double>(arg));
+  }
+};
+
+// uint64_t <> BigInt
+template <> struct JSIConverter<uint64_t> {
+  static double fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+    return arg.asBigInt(runtime).asUint64(runtime);
+  }
+  static jsi::Value toJSI(jsi::Runtime& runtime, uint64_t arg) {
+    return jsi::BigInt::fromUint64(runtime, arg);
+  }
+};
+
+// int64_t <> BigInt
+template <> struct JSIConverter<int64_t> {
+  static double fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+    return arg.asBigInt(runtime).asInt64(runtime);
+  }
+  static jsi::Value toJSI(jsi::Runtime& runtime, int64_t arg) {
+    return jsi::BigInt::fromInt64(runtime, arg);
+  }
+};
+
+
+// bool <> boolean
+template <> struct JSIConverter<bool> {
+  static bool fromJSI(jsi::Runtime&, const jsi::Value& arg, bool outOfBound) {
+    return arg.asBool();
+  }
+  static jsi::Value toJSI(jsi::Runtime&, bool arg) {
+    return jsi::Value(arg);
+  }
+};
+
+// std::string <> string
+template <> struct JSIConverter<std::string> {
+  static std::string fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+    return arg.asString(runtime).utf8(runtime);
+  }
+  static jsi::Value toJSI(jsi::Runtime& runtime, const std::string& arg) {
+    return jsi::String::createFromUtf8(runtime, arg);
+  }
+};
+
+// std::optional<T> <> T | undefined
+template <typename TInner> struct JSIConverter<std::optional<TInner>> {
+  static std::optional<TInner> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+    if (outOfBound || arg.isUndefined()) {
+      return {};
+    } else {
+      return JSIConverter<TInner>::fromJSI(runtime, std::move(arg), outOfBound);
+    }
+  }
+  static jsi::Value toJSI(jsi::Runtime& runtime, const std::optional<TInner>& arg) {
+    if (arg == std::nullopt) {
+      return jsi::Value::undefined();
+    } else {
+      return JSIConverter<TInner>::toJSI(runtime, arg.value());
+    }
+  }
+};
+
+// Enum <> Union
+template <typename TEnum> struct JSIConverter<TEnum, std::enable_if_t<std::is_enum<TEnum>::value>> {
+  static TEnum fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+    std::string string = arg.asString(runtime).utf8(runtime);
+    TEnum outEnum;
+    EnumMapper::convertJSUnionToEnum(string, &outEnum);
+    return outEnum;
+  }
+  static jsi::Value toJSI(jsi::Runtime& runtime, const TEnum& arg) {
+    std::string outUnion;
+    EnumMapper::convertEnumToJSUnion(arg, &outUnion);
+    return jsi::String::createFromUtf8(runtime, outUnion);
+  }
+};
+
+// std::future<T> <> Promise<T>
+template <typename TResult> struct JSIConverter<std::future<TResult>> {
+  static std::future<TResult> fromJSI(jsi::Runtime&, const jsi::Value&, bool outOfBound) {
+    throw std::runtime_error("Promise cannot be converted to a native type - it needs to be awaited first!");
+  }
+  static jsi::Value toJSI(jsi::Runtime& runtime, std::future<TResult>&& arg) {
+    auto sharedFuture = std::make_shared<std::future<TResult>>(std::move(arg));
+    return Promise::createPromise(runtime, [sharedFuture = std::move(sharedFuture)](jsi::Runtime& runtime,
+                                                                                           std::shared_ptr<Promise> promise) {
+      try {
+        // wait until the future completes.
+        sharedFuture->wait();
+
+        if constexpr (std::is_same_v<TResult, void>) {
+          // it's returning void, just return undefined to JS
+          sharedFuture->get();
+          promise->resolve(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, result);
+          promise->resolve(std::move(jsResult));
+        }
+      } catch (const std::exception& exception) {
+        // the async function threw an error, reject the promise
+        std::string what = exception.what();
+        promise->reject(what);
+      } catch (...) {
+        // the async function threw a non-std error, try getting it
+#if __has_include(<cxxabi.h>)
+        std::string name = __cxxabiv1::__cxa_current_exception_type()->name();
+#else
+        std::string name = "<unknown>";
+#endif
+        promise->reject("Unknown non-std exception: " + name);
+      }
+
+      // This lambda owns the promise shared pointer, and we need to call its
+      // destructor correctly here - ensuring it's properly handled.
+      promise = nullptr;
+    });
+  }
+};
+
+
+// [](Args...) -> T {} <> (Args...) => T
+template <typename ReturnType, typename... Args> struct JSIConverter<std::function<ReturnType(Args...)>> {
+  static std::function<ReturnType(Args...)> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+    jsi::Function function = arg.asObject(runtime).asFunction(runtime);
+
+    std::shared_ptr<jsi::Function> sharedFunction = JSIHelper::createSharedJsiFunction(runtime, std::move(function));
+    return [&runtime, sharedFunction, outOfBound](Args... args) -> ReturnType {
+      jsi::Value result = sharedFunction->call(runtime, JSIConverter<std::decay_t<Args>>::toJSI(runtime, args)...);
+      if constexpr (std::is_same_v<ReturnType, void>) {
+        // it is a void function (returns undefined)
+        return;
+      } else {
+        // it returns a custom type, parse it from the JSI value.
+        return JSIConverter<ReturnType>::fromJSI(runtime, std::move(result), outOfBound);
+      }
+    };
+  }
+
+  template <size_t... Is>
+  static jsi::Value callHybridFunction(const std::function<ReturnType(Args...)>& function, jsi::Runtime& runtime, const jsi::Value* args,
+                                       std::index_sequence<Is...>, size_t count) {
+    if constexpr (std::is_same_v<ReturnType, void>) {
+      // it is a void function (will return undefined in JS)
+      function(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is], Is >= count)...);
+      return jsi::Value::undefined();
+    } else {
+      // it is a custom type, parse it to a JS value
+      ReturnType result = function(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is], Is >= count)...);
+      return JSIConverter<ReturnType>::toJSI(runtime, result);
+    }
+  }
+  static jsi::Value toJSI(jsi::Runtime& runtime, const 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 {
+      if (count != sizeof...(Args)) {
+        [[unlikely]];
+        throw jsi::JSError(runtime, "Function expected " + std::to_string(sizeof...(Args)) + " arguments, but received " +
+                                        std::to_string(count) + "!");
+      }
+      return callHybridFunction(function, runtime, args, std::index_sequence_for<Args...>{}, count);
+    };
+    return jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, "hostFunction"), sizeof...(Args), jsFunction);
+  }
+};
+
+// std::vector<T> <> T[]
+template <typename ElementType> struct JSIConverter<std::vector<ElementType>> {
+  static std::vector<ElementType> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+    jsi::Array array = arg.asObject(runtime).asArray(runtime);
+    size_t length = array.size(runtime);
+
+    std::vector<ElementType> vector;
+    vector.reserve(length);
+    for (size_t i = 0; i < length; ++i) {
+      jsi::Value elementValue = array.getValueAtIndex(runtime, i);
+      vector.emplace_back(JSIConverter<ElementType>::fromJSI(runtime, elementValue, outOfBound));
+    }
+    return vector;
+  }
+  static jsi::Value toJSI(jsi::Runtime& runtime, const std::vector<ElementType>& vector) {
+    jsi::Array array(runtime, vector.size());
+    for (size_t i = 0; i < vector.size(); i++) {
+      jsi::Value value = JSIConverter<ElementType>::toJSI(runtime, vector[i]);
+      array.setValueAtIndex(runtime, i, std::move(value));
+    }
+    return array;
+  }
+};
+
+// std::unordered_map<std::string, T> <> Record<string, T>
+template <typename ValueType> struct JSIConverter<std::unordered_map<std::string, ValueType>> {
+  static std::unordered_map<std::string, ValueType> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+    jsi::Object object = arg.asObject(runtime);
+    jsi::Array propertyNames = object.getPropertyNames(runtime);
+    size_t length = propertyNames.size(runtime);
+
+    std::unordered_map<std::string, ValueType> map;
+    map.reserve(length);
+    for (size_t i = 0; i < length; ++i) {
+      std::string key = propertyNames.getValueAtIndex(runtime, i).asString(runtime).utf8(runtime);
+      jsi::Value value = object.getProperty(runtime, key.c_str());
+      map.emplace(key, JSIConverter<ValueType>::fromJSI(runtime, value, outOfBound));
+    }
+    return map;
+  }
+  static jsi::Value toJSI(jsi::Runtime& runtime, const std::unordered_map<std::string, ValueType>& map) {
+    jsi::Object object(runtime);
+    for (const auto& pair : map) {
+      jsi::Value value = JSIConverter<ValueType>::toJSI(runtime, pair.second);
+      jsi::String key = jsi::String::createFromUtf8(runtime, pair.first);
+      object.setProperty(runtime, key, std::move(value));
+    }
+    return object;
+  }
+};
+
+// HybridObject <> {}
+template <typename T> struct is_shared_ptr_to_host_object : std::false_type {};
+
+template <typename T> struct is_shared_ptr_to_host_object<std::shared_ptr<T>> : std::is_base_of<jsi::HostObject, T> {};
+
+template <typename T> struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_host_object<T>::value>> {
+  using TPointee = typename T::element_type;
+
+#if DEBUG
+  inline static std::string getFriendlyTypename() {
+    std::string name = std::string(typeid(TPointee).name());
+#if __has_include(<cxxabi.h>)
+    int status = 0;
+    char* demangled_name = abi::__cxa_demangle(name.c_str(), NULL, NULL, &status);
+    if (status == 0) {
+      name = demangled_name;
+      std::free(demangled_name);
+    }
+#endif
+    return name;
+  }
+
+  inline static std::string invalidTypeErrorMessage(const std::string& typeDescription, const std::string& reason) {
+    return "Cannot convert \"" + typeDescription + "\" to HostObject<" + getFriendlyTypename() + ">! " + reason;
+  }
+#endif
+
+  static T fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+#if DEBUG
+    if (arg.isUndefined()) {
+      [[unlikely]];
+      throw jsi::JSError(runtime, invalidTypeErrorMessage("undefined", "It is undefined!"));
+    }
+    if (!arg.isObject()) {
+      [[unlikely]];
+      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not an object!"));
+    }
+#endif
+    jsi::Object object = arg.getObject(runtime);
+#if DEBUG
+    if (!object.isHostObject<TPointee>(runtime)) {
+      [[unlikely]];
+      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is a different HostObject<T>!"));
+    }
+#endif
+    return object.getHostObject<TPointee>(runtime);
+  }
+  static jsi::Value toJSI(jsi::Runtime& runtime, const T& arg) {
+#if DEBUG
+    if (arg == nullptr) {
+      [[unlikely]];
+      throw jsi::JSError(runtime, "Cannot convert nullptr to HostObject<" + getFriendlyTypename() + ">!");
+    }
+#endif
+    return jsi::Object::createFromHostObject(runtime, arg);
+  }
+};
+
+// NativeState <> {}
+template <typename T> struct is_shared_ptr_to_native_state : std::false_type {};
+
+template <typename T> struct is_shared_ptr_to_native_state<std::shared_ptr<T>> : std::is_base_of<jsi::NativeState, T> {};
+
+template <typename T> struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_native_state<T>::value>> {
+  using TPointee = typename T::element_type;
+
+#if DEBUG
+  inline static std::string getFriendlyTypename() {
+    std::string name = std::string(typeid(TPointee).name());
+#if __has_include(<cxxabi.h>)
+    int status = 0;
+    char* demangled_name = abi::__cxa_demangle(name.c_str(), NULL, NULL, &status);
+    if (status == 0) {
+      name = demangled_name;
+      std::free(demangled_name);
+    }
+#endif
+    return name;
+  }
+
+  inline static std::string invalidTypeErrorMessage(const std::string& typeDescription, const std::string& reason) {
+    return "Cannot convert \"" + typeDescription + "\" to NativeState<" + getFriendlyTypename() + ">! " + reason;
+  }
+#endif
+
+  static T fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+#if DEBUG
+    if (arg.isUndefined()) {
+      [[unlikely]];
+      throw jsi::JSError(runtime, invalidTypeErrorMessage("undefined", "It is undefined!"));
+    }
+    if (!arg.isObject()) {
+      [[unlikely]];
+      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not an object!"));
+    }
+#endif
+    jsi::Object object = arg.getObject(runtime);
+#if DEBUG
+    if (!object.hasNativeState<TPointee>(runtime)) {
+      [[unlikely]];
+      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is a different NativeState<T>!"));
+    }
+#endif
+    return object.getNativeState<TPointee>(runtime);
+  }
+  static jsi::Value toJSI(jsi::Runtime& runtime, const T& arg) {
+#if DEBUG
+    if (arg == nullptr) {
+      [[unlikely]];
+      throw jsi::JSError(runtime, "Cannot convert nullptr to HostObject<" + getFriendlyTypename() + ">!");
+    }
+#endif
+    jsi::Object object(runtime);
+    object.setNativeState(runtime, arg);
+    return object;
+  }
+};
+
+} // namespace margelo

package/cpp/jsi/RNFJSIHelper.h

@@ -0,0 +1,49 @@
+//
+// Created by Hanno Gödecke on 15.05.24.
+//
+
+#pragma once
+
+#include "RNFWorkletRuntimeRegistry.h"
+#include <jsi/jsi.h>
+#include <memory>
+#include <utility>
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+class JSIHelper {
+public:
+  /**
+   * Takes a jsi::Function and wraps it in a shared_ptr so its shareable.
+   * Every jsi::Function you intend to share or hold should be wrapped using this function.
+   */
+  static std::shared_ptr<jsi::Function> createSharedJsiFunction(jsi::Runtime& runtime, jsi::Function&& function) {
+    std::shared_ptr<jsi::Function> sharedFunction(new jsi::Function(std::move(function)), [&runtime](jsi::Function* ptr) {
+      if (RNFWorkletRuntimeRegistry::isRuntimeAlive(&runtime)) {
+        // Only delete the jsi::Function when the runtime it created is still alive.
+        // Otherwise leak memory. We do this on purpose, as sometimes we would keep
+        // references to JSI objects past the lifetime of its runtime (e.g.,
+        // shared values references from the RN VM holds reference to JSI objects
+        // on the UI runtime). When the runtime is terminated, the orphaned JSI
+        // objects would crash the app when their destructors are called, because
+        // they call into a memory that's managed by the terminated runtime. We
+        // accept the tradeoff of leaking memory here, as it has a limited impact.
+        // This scenario can only occur when the React instance is torn down which
+        // happens in development mode during app reloads, or in production when
+        // the app is being shut down gracefully by the system. An alternative
+        // solution would require us to keep track of all JSI values that are in
+        // use which would require additional data structure and compute spent on
+        // bookkeeping that only for the sake of destroying the values in time
+        // before the runtime is terminated. Note that the underlying memory that
+        // jsi::Value refers to is managed by the VM and gets freed along with the
+        // runtime.
+        delete ptr;
+      }
+    });
+
+    return sharedFunction;
+  }
+};
+} // namespace margelo

package/cpp/jsi/RNFPointerHolder.h

@@ -0,0 +1,95 @@
+//
+// Created by Marc Rousavy on 16.04.24.
+//
+
+#pragma once
+
+#include "RNFHybridObject.h"
+#include "RNFLogger.h"
+#include <memory>
+#include <mutex>
+#include <utility>
+#include <string>
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+template <typename T> class PointerHolder : public HybridObject {
+protected:
+  // no default constructor
+  PointerHolder() = delete;
+
+  /**
+   * Create a new instance of a pointer holder which holds the given shared_ptr.
+   * @param name The name of the implementing class, for example "ViewWrapper".
+   * @param pointer The pointer this class will hold. It might be released from JS at any point via `release()`.
+   */
+  PointerHolder(const char* name, std::shared_ptr<T> pointer) : HybridObject(name), _name(name), _pointer(pointer) {
+    // eagerly initialize the release() method instead of putting it in `loadHybridMethods`
+    registerHybridMethod("release", &PointerHolder<T>::release, this);
+    registerHybridGetter("isValid", &PointerHolder<T>::getIsValid, this);
+  }
+
+  /**
+   * Create a new instance of a pointer holder which holds a shared_ptr of the given value.
+   * The shared_ptr will be move-constructed.
+   * @param name The name of the implementing class, for example "ViewWrapper".
+   * @param value The value this class will hold as a shared_ptr. It might be destroyed from JS at any point via `release()`.
+   */
+  PointerHolder(const char* name, T&& value) : PointerHolder(name, std::make_shared<T>(std::move(value))) {}
+
+  /**
+   * Called when the PointerHolder gets automatically destroyed (e.g. via GC) and the shared_ptr will be destroyed.
+   */
+  ~PointerHolder() {
+    if (_pointer != nullptr) {
+      Logger::log(TAG, "Automatically releasing %s... (~PointerHolder())", _name.c_str());
+    }
+  }
+
+protected:
+  /**
+   * Manually release this reference to the pointer.
+   * If there are any other references to this pointer, no memory will be force-deleted.
+   */
+  virtual void release() {
+    std::unique_lock lock(_mutex);
+
+    if (_pointer == nullptr) {
+      throw std::runtime_error("Pointer " + _name + " has already been manually released!");
+    }
+    Logger::log(TAG, "Manually releasing %s... (PointerHolder::release())", _name.c_str());
+    _pointer = nullptr;
+  }
+
+  /**
+   * Get the shared_ptr this class is holding.
+   * If it has already been manually released from JS, this method will throw a runtime_error.
+   */
+  std::shared_ptr<T> pointee() {
+    std::unique_lock lock(_mutex);
+
+    if (_pointer == nullptr) {
+      throw std::runtime_error("Pointer " + _name + " has already been manually released!");
+    }
+    return _pointer;
+  }
+
+  /**
+   * Get if the pointer is still valid and strong.
+   */
+  bool getIsValid() {
+    std::unique_lock lock(_mutex);
+
+    return _pointer != nullptr;
+  }
+
+private:
+  std::string _name;
+  std::shared_ptr<T> _pointer;
+  std::mutex _mutex;
+  static constexpr auto TAG = "PointerHolder";
+};
+
+} // namespace margelo

package/cpp/jsi/RNFPromise.cpp

@@ -0,0 +1,45 @@
+//
+// Created by Marc Rousavy on 22.02.24.
+//
+#include "RNFPromise.h"
+#include <future>
+#include <jsi/jsi.h>
+#include <utility>
+#include <vector>
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+Promise::Promise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter)
+    : runtime(runtime), _resolver(std::move(resolver)), _rejecter(std::move(rejecter)) {}
+
+jsi::Value Promise::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,
+      [=](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments, size_t count) -> jsi::Value {
+        // Call function
+        auto resolver = arguments[0].asObject(runtime).asFunction(runtime);
+        auto rejecter = arguments[1].asObject(runtime).asFunction(runtime);
+        auto promise = std::make_shared<Promise>(runtime, std::move(resolver), std::move(rejecter));
+        run(runtime, promise);
+
+        return jsi::Value::undefined();
+      });
+
+  return promiseCtor.callAsConstructor(runtime, promiseCallback);
+}
+
+void Promise::resolve(jsi::Value&& result) {
+  _resolver.call(runtime, std::move(result));
+}
+
+void Promise::reject(std::string message) {
+  jsi::JSError error(runtime, message);
+  _rejecter.call(runtime, error.value());
+}
+
+} // namespace margelo

package/cpp/jsi/RNFPromise.h

@@ -0,0 +1,38 @@
+//
+// Created by Marc Rousavy on 22.02.24.
+//
+#pragma once
+
+#include <jsi/jsi.h>
+#include <utility>
+#include <vector>
+#include <string>
+#include <memory>
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+class Promise {
+public:
+  Promise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter);
+
+  void resolve(jsi::Value&& result);
+  void reject(std::string error);
+
+public:
+  jsi::Runtime& runtime;
+
+private:
+  jsi::Function _resolver;
+  jsi::Function _rejecter;
+
+public:
+  using RunPromise = std::function<void(jsi::Runtime& runtime, std::shared_ptr<Promise> promise)>;
+  /**
+   Create a new Promise and runs the given `run` function.
+   */
+  static jsi::Value createPromise(jsi::Runtime& runtime, RunPromise run);
+};
+
+} // namespace margelo