react-native-executorch 0.4.10 → 0.5.0-nightly-6f4dd53-20251211

package/common/rnexecutorch/host_objects/ModelHostObject.h

@@ -0,0 +1,313 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <sstream>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <type_traits>
+
+#include <memory.h>
+#include <rnexecutorch/TokenizerModule.h>
+#include <rnexecutorch/host_objects/JSTensorViewOut.h>
+#include <rnexecutorch/host_objects/JsiConversions.h>
+#include <rnexecutorch/jsi/JsiHostObject.h>
+#include <rnexecutorch/jsi/Promise.h>
+#include <rnexecutorch/metaprogramming/FunctionHelpers.h>
+#include <rnexecutorch/metaprogramming/TypeConcepts.h>
+#include <rnexecutorch/models/BaseModel.h>
+#include <rnexecutorch/models/llm/LLM.h>
+#include <rnexecutorch/models/ocr/OCR.h>
+#include <rnexecutorch/models/speech_to_text/SpeechToText.h>
+#include <rnexecutorch/models/text_to_image/TextToImage.h>
+#include <rnexecutorch/models/vertical_ocr/VerticalOCR.h>
+#include <rnexecutorch/threads/GlobalThreadPool.h>
+
+namespace rnexecutorch {
+
+template <typename Model> class ModelHostObject : public JsiHostObject {
+public:
+  explicit ModelHostObject(const std::shared_ptr<Model> &model,
+                           std::shared_ptr<react::CallInvoker> callInvoker)
+      : model(model), callInvoker(callInvoker) {
+    if constexpr (meta::DerivedFromOrSameAs<Model, models::BaseModel>) {
+      addFunctions(
+          JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
+    }
+
+    if constexpr (meta::DerivedFromOrSameAs<Model, models::BaseModel>) {
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::forwardJS>,
+                                       "forward"));
+    }
+
+    if constexpr (meta::DerivedFromOrSameAs<Model, models::BaseModel>) {
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>, promiseHostFunction<&Model::getInputShape>,
+          "getInputShape"));
+    }
+
+    if constexpr (meta::HasGenerate<Model>) {
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::generate>,
+                                       "generate"));
+    }
+
+    if constexpr (meta::HasEncode<Model>) {
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::encode>,
+                                       "encode"));
+    }
+
+    if constexpr (meta::HasDecode<Model>) {
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::decode>,
+                                       "decode"));
+    }
+
+    if constexpr (meta::SameAs<Model, models::speech_to_text::SpeechToText>) {
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       synchronousHostFunction<&Model::unload>,
+                                       "unload"));
+
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::transcribe>,
+                                       "transcribe"));
+
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::stream>,
+                                       "stream"));
+
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>, synchronousHostFunction<&Model::streamInsert>,
+          "streamInsert"));
+
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>, synchronousHostFunction<&Model::streamStop>,
+          "streamStop"));
+    }
+
+    if constexpr (meta::SameAs<Model, TokenizerModule>) {
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::encode>,
+                                       "encode"));
+
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::decode>,
+                                       "decode"));
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>, promiseHostFunction<&Model::getVocabSize>,
+          "getVocabSize"));
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::idToToken>,
+                                       "idToToken"));
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::tokenToId>,
+                                       "tokenToId"));
+    }
+
+    if constexpr (meta::SameAs<Model, models::llm::LLM>) {
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::generate>,
+                                       "generate"));
+
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>, synchronousHostFunction<&Model::interrupt>,
+          "interrupt"));
+
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>,
+          synchronousHostFunction<&Model::getGeneratedTokenCount>,
+          "getGeneratedTokenCount"));
+
+      addFunctions(
+          JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                              synchronousHostFunction<&Model::setCountInterval>,
+                              "setCountInterval"));
+
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>,
+          synchronousHostFunction<&Model::setTimeInterval>, "setTimeInterval"));
+
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>,
+          synchronousHostFunction<&Model::setTemperature>, "setTemperature"));
+
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       synchronousHostFunction<&Model::setTopp>,
+                                       "setTopp"));
+
+      addFunctions(
+          JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
+    }
+
+    if constexpr (meta::SameAs<Model, models::text_to_image::TextToImage>) {
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>, synchronousHostFunction<&Model::interrupt>,
+          "interrupt"));
+    }
+
+    if constexpr (meta::SameAs<Model, models::ocr::OCR>) {
+      addFunctions(
+          JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
+    }
+
+    if constexpr (meta::SameAs<Model, models::ocr::VerticalOCR>) {
+      addFunctions(
+          JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
+    }
+  }
+
+  // A generic host function that runs synchronously, works analogously to the
+  // generic promise host function.
+  template <auto FnPtr> JSI_HOST_FUNCTION(synchronousHostFunction) {
+    constexpr std::size_t functionArgCount = meta::getArgumentCount(FnPtr);
+    if (functionArgCount != count) {
+      std::stringstream ss;
+      ss << "Argument count mismatch, was expecting: " << functionArgCount
+         << " but got: " << count;
+      const auto errorMessage = ss.str();
+      throw jsi::JSError(runtime, errorMessage);
+    }
+
+    try {
+      auto argsConverted = meta::createArgsTupleFromJsi(FnPtr, args, runtime);
+
+      if constexpr (std::is_void_v<decltype(std::apply(
+                        std::bind_front(FnPtr, model), argsConverted))>) {
+        // For void functions, just call the function and return undefined
+        std::apply(std::bind_front(FnPtr, model), std::move(argsConverted));
+        return jsi::Value::undefined();
+      } else {
+        // For non-void functions, capture the result and convert it
+        auto result =
+            std::apply(std::bind_front(FnPtr, model), std::move(argsConverted));
+        return jsi_conversion::getJsiValue(std::move(result), runtime);
+      }
+    } catch (const std::runtime_error &e) {
+      // This catch should be merged with the next one
+      // (std::runtime_error inherits from std::exception) HOWEVER react
+      // native has broken RTTI which breaks proper exception type
+      // checking. Remove when the following change is present in our
+      // version:
+      // https://github.com/facebook/react-native/commit/3132cc88dd46f95898a756456bebeeb6c248f20e
+      throw jsi::JSError(runtime, e.what());
+    } catch (const std::exception &e) {
+      throw jsi::JSError(runtime, e.what());
+    } catch (...) {
+      throw jsi::JSError(runtime, "Unknown error in synchronous function");
+    }
+  }
+
+  // A generic host function that resolves a promise with a result of a
+  // function. JSI arguments are converted to the types provided in the function
+  // signature, and the return value is converted back to JSI before resolving.
+  template <auto FnPtr> JSI_HOST_FUNCTION(promiseHostFunction) {
+    auto promise = Promise::createPromise(
+        runtime, callInvoker,
+        [this, count, args, &runtime](std::shared_ptr<Promise> promise) {
+          constexpr std::size_t functionArgCount =
+              meta::getArgumentCount(FnPtr);
+          if (functionArgCount != count) {
+            std::stringstream ss;
+            ss << "Argument count mismatch, was expecting: " << functionArgCount
+               << " but got: " << count;
+            const auto errorMessage = ss.str();
+            promise->reject(errorMessage);
+            return;
+          }
+
+          try {
+            auto argsConverted =
+                meta::createArgsTupleFromJsi(FnPtr, args, runtime);
+
+            // We need to dispatch a thread if we want the function to be
+            // asynchronous. In this thread all accesses to jsi::Runtime need to
+            // be done via the callInvoker.
+            threads::GlobalThreadPool::detach(
+                [this, promise, argsConverted = std::move(argsConverted)]() {
+                  try {
+                    if constexpr (std::is_void_v<decltype(std::apply(
+                                      std::bind_front(FnPtr, model),
+                                      argsConverted))>) {
+                      // For void functions, just call the function and resolve
+                      // with undefined
+                      std::apply(std::bind_front(FnPtr, model),
+                                 std::move(argsConverted));
+                      callInvoker->invokeAsync(
+                          [promise](jsi::Runtime &runtime) {
+                            promise->resolve(jsi::Value::undefined());
+                          });
+                    } else {
+                      // For non-void functions, capture the result and convert
+                      // it
+                      auto result = std::apply(std::bind_front(FnPtr, model),
+                                               std::move(argsConverted));
+                      // The result is copied. It should either be quickly
+                      // copiable, or passed with a shared_ptr.
+                      callInvoker->invokeAsync(
+                          [promise, result](jsi::Runtime &runtime) {
+                            promise->resolve(jsi_conversion::getJsiValue(
+                                std::move(result), runtime));
+                          });
+                    }
+                  } catch (const std::runtime_error &e) {
+                    // This catch should be merged with the next two
+                    // (std::runtime_error and jsi::JSError inherits from
+                    // std::exception) HOWEVER react native has broken RTTI
+                    // which breaks proper exception type checking. Remove when
+                    // the following change is present in our version:
+                    // https://github.com/facebook/react-native/commit/3132cc88dd46f95898a756456bebeeb6c248f20e
+                    callInvoker->invokeAsync([e = std::move(e), promise]() {
+                      promise->reject(e.what());
+                    });
+                    return;
+                  } catch (const jsi::JSError &e) {
+                    callInvoker->invokeAsync([e = std::move(e), promise]() {
+                      promise->reject(e.what());
+                    });
+                    return;
+                  } catch (const std::exception &e) {
+                    callInvoker->invokeAsync([e = std::move(e), promise]() {
+                      promise->reject(e.what());
+                    });
+                    return;
+                  } catch (...) {
+                    callInvoker->invokeAsync(
+                        [promise]() { promise->reject("Unknown error"); });
+                    return;
+                  }
+                });
+          } catch (...) {
+            promise->reject("Couldn't parse JS arguments in a native function");
+          }
+        });
+
+    return promise;
+  }
+
+  JSI_HOST_FUNCTION(unload) {
+    try {
+      model->unload();
+    } catch (const std::runtime_error &e) {
+      // This catch should be merged with the next one
+      // (std::runtime_error inherits from std::exception) HOWEVER react
+      // native has broken RTTI which breaks proper exception type
+      // checking. Remove when the following change is present in our
+      // version:
+      // https://github.com/facebook/react-native/commit/3132cc88dd46f95898a756456bebeeb6c248f20e
+      throw jsi::JSError(runtime, e.what());
+    } catch (const std::exception &e) {
+      throw jsi::JSError(runtime, e.what());
+    } catch (...) {
+      throw jsi::JSError(runtime, "Unknown error while unloading a model");
+    }
+    return jsi::Value::undefined();
+  }
+
+private:
+  std::shared_ptr<Model> model;
+  std::shared_ptr<react::CallInvoker> callInvoker;
+};
+
+} // namespace rnexecutorch

package/common/rnexecutorch/jsi/JsiHostObject.cpp

@@ -0,0 +1,108 @@
+#include "JsiHostObject.h"
+
+//  set this value to 1 in order to debug the construction/destruction
+#define JSI_DEBUG_ALLOCATIONS 1
+
+namespace rnexecutorch {
+
+#if JSI_DEBUG_ALLOCATIONS
+int objCounter = 0;
+std::vector<JsiHostObject *> objects;
+#endif
+
+JsiHostObject::JsiHostObject() {
+  getters_ = std::make_unique<std::unordered_map<
+      std::string, jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>();
+  functions_ = std::make_unique<
+      std::unordered_map<std::string, jsi::Value (JsiHostObject::*)(
+                                          jsi::Runtime &, const jsi::Value &,
+                                          const jsi::Value *, size_t)>>();
+  setters_ = std::make_unique<std::unordered_map<
+      std::string,
+      void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>();
+
+#if JSI_DEBUG_ALLOCATIONS
+  objects.push_back(this);
+  objCounter++;
+#endif
+}
+
+JsiHostObject::~JsiHostObject() {
+#if JSI_DEBUG_ALLOCATIONS
+  for (size_t i = 0; i < objects.size(); ++i) {
+    if (objects.at(i) == this) {
+      objects.erase(objects.begin() + i);
+      break;
+    }
+  }
+  objCounter--;
+#endif
+}
+
+std::vector<jsi::PropNameID> JsiHostObject::getPropertyNames(jsi::Runtime &rt) {
+  std::vector<jsi::PropNameID> propertyNames;
+  propertyNames.reserve(getters_->size() + functions_->size() +
+                        setters_->size());
+
+  for (const auto &it : *getters_) {
+    propertyNames.push_back(jsi::PropNameID::forUtf8(rt, it.first));
+  }
+
+  for (const auto &it : *functions_) {
+    propertyNames.push_back(jsi::PropNameID::forAscii(rt, it.first));
+  }
+
+  for (const auto &it : *setters_) {
+    propertyNames.push_back(jsi::PropNameID::forAscii(rt, it.first));
+  }
+
+  return propertyNames;
+}
+
+jsi::Value JsiHostObject::get(jsi::Runtime &runtime,
+                              const jsi::PropNameID &name) {
+  auto nameAsString = name.utf8(runtime);
+  auto &hostFunctionCache = hostFunctionCache_.get(runtime);
+
+  auto cachedFunction = hostFunctionCache.find(nameAsString);
+  if (cachedFunction != hostFunctionCache.end()) {
+    return cachedFunction->second.asFunction(runtime);
+  }
+
+  auto getter = getters_->find(nameAsString);
+  if (getter != getters_->end()) {
+    auto dispatcher = std::bind(getter->second, this, std::placeholders::_1);
+
+    return dispatcher(runtime);
+  }
+
+  auto function = functions_->find(nameAsString);
+  if (function == functions_->end()) {
+    return jsi::Value::undefined();
+  }
+
+  auto dispatcher =
+      std::bind(function->second, reinterpret_cast<JsiHostObject *>(this),
+                std::placeholders::_1, std::placeholders::_2,
+                std::placeholders::_3, std::placeholders::_4);
+
+  return hostFunctionCache
+      .emplace(nameAsString, jsi::Function::createFromHostFunction(
+                                 runtime, name, 0, dispatcher))
+      .first->second.asFunction(runtime);
+}
+
+void JsiHostObject::set(jsi::Runtime &runtime, const jsi::PropNameID &name,
+                        const jsi::Value &value) {
+  auto nameAsString = name.utf8(runtime);
+
+  auto setter = setters_->find(nameAsString);
+
+  if (setter != setters_->end()) {
+    auto dispatcher = std::bind(setter->second, this, std::placeholders::_1,
+                                std::placeholders::_2);
+
+    return dispatcher(runtime, value);
+  }
+}
+} // namespace rnexecutorch

package/common/rnexecutorch/jsi/JsiHostObject.h

@@ -0,0 +1,87 @@
+#pragma once
+// Adapted from https://github.com/software-mansion/react-native-audio-api
+
+#include <rnexecutorch/jsi/RuntimeAwareCache.h>
+
+#include <jsi/jsi.h>
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#define JSI_HOST_FUNCTION(NAME)                                                \
+  jsi::Value NAME(jsi::Runtime &runtime, const jsi::Value &thisValue,          \
+                  const jsi::Value *args, size_t count)
+
+#define JSI_EXPORT_FUNCTION(CLASS, FUNCTION, NAME)                             \
+  std::make_pair(                                                              \
+      NAME,                                                                    \
+      static_cast<jsi::Value (JsiHostObject::*)(                               \
+          jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>(    \
+          &CLASS::FUNCTION))
+
+#define JSI_PROPERTY_GETTER(name) jsi::Value name(jsi::Runtime &runtime)
+
+#define JSI_EXPORT_PROPERTY_GETTER(CLASS, FUNCTION)                            \
+  std::make_pair(std::string(#FUNCTION),                                       \
+                 static_cast<jsi::Value (JsiHostObject::*)(jsi::Runtime &)>(   \
+                     &CLASS::FUNCTION))
+
+#define JSI_PROPERTY_SETTER(name)                                              \
+  void name(jsi::Runtime &runtime, const jsi::Value &value)
+
+#define JSI_EXPORT_PROPERTY_SETTER(CLASS, FUNCTION)                            \
+  std::make_pair(std::string(#FUNCTION),                                       \
+                 static_cast<void (JsiHostObject::*)(                          \
+                     jsi::Runtime &, const jsi::Value &)>(&CLASS::FUNCTION))
+
+namespace rnexecutorch {
+
+using namespace facebook;
+
+class JsiHostObject : public jsi::HostObject {
+public:
+  JsiHostObject();
+  ~JsiHostObject() override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+
+  void set(jsi::Runtime &runtime, const jsi::PropNameID &name,
+           const jsi::Value &value) override;
+
+  template <typename... Args> void addGetters(Args... args) {
+    (getters_->insert(args), ...);
+  }
+
+  template <typename... Args> void addSetters(Args... args) {
+    (setters_->insert(args), ...);
+  }
+
+  template <typename... Args> void addFunctions(Args... args) {
+    (functions_->insert(args), ...);
+  }
+
+protected:
+  std::unique_ptr<std::unordered_map<std::string, jsi::Value (JsiHostObject::*)(
+                                                      jsi::Runtime &)>>
+      getters_;
+
+  std::unique_ptr<
+      std::unordered_map<std::string, jsi::Value (JsiHostObject::*)(
+                                          jsi::Runtime &, const jsi::Value &,
+                                          const jsi::Value *, size_t)>>
+      functions_;
+
+  std::unique_ptr<std::unordered_map<
+      std::string, void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>
+      setters_;
+
+private:
+  RuntimeAwareCache<std::map<std::string, jsi::Function>> hostFunctionCache_;
+};
+
+} // namespace rnexecutorch

package/common/rnexecutorch/jsi/OwningArrayBuffer.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <vector>
+
+namespace rnexecutorch {
+
+using namespace facebook;
+
+/**
+ * JSI offers the MutableBuffer as an interface for accessing native memory
+ * directly from JS. A class inheriting from the MutableBuffer could be used to
+ * access memory which is owned by C++ or memory which should be freed once JS
+ * is done with it. OwningArrayBuffer is an example of the latter, memory is
+ * allocated on creation and freed on deletion. JS holds a pointer to all
+ * MutableBuffers via a shared_ptr, so the destructor will be called only when
+ * no reference to it is kept. For a handy JS access to the data, MutableBuffers
+ * can be inspected via a data view, such as Float32Array. See
+ * ImageSegmentation.cpp for an example usage.
+ */
+class OwningArrayBuffer : public jsi::MutableBuffer {
+public:
+  /**
+   * @param size Size of the buffer in bytes.
+   */
+  OwningArrayBuffer(size_t size) : size_(size) {
+    data_ = new uint8_t[size_];
+  }
+  /**
+   * @param data Pointer to the source data.
+   * @param size Size of the data in bytes.
+   */
+  OwningArrayBuffer(const auto &data, size_t size) : size_(size) {
+    data_ = new uint8_t[size_];
+    std::memcpy(data_, data, size_);
+  }
+  template <typename T>
+  OwningArrayBuffer(const std::vector<T> &vec) : size_(vec.size() * sizeof(T)) {
+    data_ = new uint8_t[size_];
+    std::memcpy(data_, vec.data(), size_);
+  }
+  ~OwningArrayBuffer() override { delete[] data_; }
+
+  OwningArrayBuffer(const OwningArrayBuffer &) = delete;
+  OwningArrayBuffer(OwningArrayBuffer &&) = delete;
+  OwningArrayBuffer &operator=(const OwningArrayBuffer &) = delete;
+  OwningArrayBuffer &operator=(OwningArrayBuffer &&) = delete;
+
+  [[nodiscard]] size_t size() const override { return size_; }
+  uint8_t *data() override { return data_; }
+
+private:
+  uint8_t *data_;
+  const size_t size_;
+};
+
+} // namespace rnexecutorch

package/common/rnexecutorch/jsi/Promise.cpp

@@ -0,0 +1,20 @@
+#include "Promise.h"
+
+namespace rnexecutorch {
+
+Promise::Promise(jsi::Runtime &runtime,
+                 std::shared_ptr<react::CallInvoker> callInvoker,
+                 jsi::Value resolver, jsi::Value rejecter)
+    : runtime(runtime), callInvoker(callInvoker),
+      _resolver(std::move(resolver)), _rejecter(std::move(rejecter)) {}
+
+void Promise::resolve(jsi::Value &&result) {
+  _resolver.asObject(runtime).asFunction(runtime).call(runtime, result);
+}
+
+void Promise::reject(std::string message) {
+  jsi::JSError error(runtime, message);
+  _rejecter.asObject(runtime).asFunction(runtime).call(runtime, error.value());
+}
+
+} // namespace rnexecutorch

package/common/rnexecutorch/jsi/Promise.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+
+namespace rnexecutorch {
+
+using namespace facebook;
+
+class Promise;
+
+template <typename T>
+concept PromiseRunFn =
+    std::invocable<T, std::shared_ptr<Promise>> &&
+    std::same_as<std::invoke_result_t<T, std::shared_ptr<Promise>>, void>;
+
+class Promise {
+public:
+  Promise(jsi::Runtime &runtime,
+          std::shared_ptr<react::CallInvoker> callInvoker, jsi::Value resolver,
+          jsi::Value rejecter);
+
+  Promise(const Promise &) = delete;
+  Promise &operator=(const Promise &) = delete;
+
+  void resolve(jsi::Value &&result);
+  void reject(std::string error);
+
+  /**
+    Creates a new promise and runs the supplied "run" function that takes this
+    promise. We use a template for the function type to not use std::function
+    and be able to bind a lambda.
+  */
+  template <PromiseRunFn Fn>
+  static jsi::Value
+  createPromise(jsi::Runtime &runtime,
+                std::shared_ptr<react::CallInvoker> callInvoker, Fn &&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),
+         callInvoker](jsi::Runtime &runtime, const jsi::Value &thisValue,
+                      const jsi::Value *arguments, size_t count) -> jsi::Value {
+          // Call function
+          auto promise = std::make_shared<Promise>(
+              runtime, callInvoker, arguments[0].asObject(runtime),
+              arguments[1].asObject(runtime));
+          run(promise);
+
+          return jsi::Value::undefined();
+        });
+
+    return promiseCtor.callAsConstructor(runtime, promiseCallback);
+  }
+
+private:
+  jsi::Runtime &runtime;
+  std::shared_ptr<react::CallInvoker> callInvoker;
+  jsi::Value _resolver;
+  jsi::Value _rejecter;
+};
+
+} // namespace rnexecutorch