feat: port + refactor ExecutorchModule to C++

packages/react-native-executorch/common/rnexecutorch/RnExecutorchInstaller.cpp

@@ -37,5 +37,11 @@ void RnExecutorchInstaller::injectJSIBindings(
       *jsiRuntime, "loadObjectDetection",
       RnExecutorchInstaller::loadModel<ObjectDetection>(
           jsiRuntime, jsCallInvoker, "loadObjectDetection"));
+
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadExecutorchModule",
+      RnExecutorchInstaller::loadModel<BaseModel>(jsiRuntime, jsCallInvoker,
+                                                  "loadExecutorchModule"));
 }
+
 } // namespace rnexecutorch

packages/react-native-executorch/common/rnexecutorch/RnExecutorchInstaller.h

@@ -7,7 +7,7 @@
 #include <ReactCommon/CallInvoker.h>
 #include <jsi/jsi.h>
 
-#include <rnexecutorch/TypeConstraints.h>
+#include <rnexecutorch/TypeConcepts.h>
 #include <rnexecutorch/host_objects/JsiConversions.h>
 #include <rnexecutorch/host_objects/ModelHostObject.h>
 
@@ -26,7 +26,7 @@ class RnExecutorchInstaller {
                     FetchUrlFunc_t fetchDataFromUrl);
 
 private:
-  template <DerivedFromBaseModel ModelT>
+  template <DerivedFromOrSameAs<BaseModel> ModelT>
   static jsi::Function
   loadModel(jsi::Runtime *jsiRuntime,
             std::shared_ptr<react::CallInvoker> jsCallInvoker,

packages/react-native-executorch/common/rnexecutorch/TypeConcepts.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <concepts>
+#include <type_traits>
+
+namespace rnexecutorch {
+
+template <typename T, typename Base>
+concept DerivedFromOrSameAs = std::is_base_of_v<Base, T>;
+
+template <typename T>
+concept HasGenerate = requires(T t) {
+  { &T::generate };
+};
+
+template <typename T>
+concept IsNumeric = std::is_arithmetic_v<T>;
+
+} // namespace rnexecutorch

packages/react-native-executorch/common/rnexecutorch/host_objects/JSTensorViewIn.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace rnexecutorch {
+
+using executorch::aten::ScalarType;
+
+struct JSTensorViewIn {
+  void *dataPtr;
+  std::vector<int32_t> sizes;
+  ScalarType scalarType;
+};
+} // namespace rnexecutorch

packages/react-native-executorch/common/rnexecutorch/host_objects/JSTensorViewOut.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <executorch/runtime/core/portable_type/scalar_type.h>
+#include <memory>
+#include <rnexecutorch/jsi/OwningArrayBuffer.h>
+#include <vector>
+
+namespace rnexecutorch {
+
+using executorch::runtime::etensor::ScalarType;
+
+struct JSTensorViewOut {
+  std::shared_ptr<OwningArrayBuffer> dataPtr;
+  std::vector<int32_t> sizes;
+  ScalarType scalarType;
+
+  JSTensorViewOut(std::vector<int32_t> sizes, ScalarType scalarType,
+                  std::shared_ptr<OwningArrayBuffer> dataPtr)
+      : sizes(std::move(sizes)), scalarType(scalarType),
+        dataPtr(std::move(dataPtr)) {}
+};
+} // namespace rnexecutorch

packages/react-native-executorch/common/rnexecutorch/host_objects/JsiConversions.h

@@ -4,8 +4,13 @@
 #include <type_traits>
 #include <unordered_map>
 
+#include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
 #include <jsi/jsi.h>
+#include <rnexecutorch/host_objects/JSTensorViewIn.h>
+#include <rnexecutorch/host_objects/JSTensorViewOut.h>
+#include <rnexecutorch/jsi/OwningArrayBuffer.h>
 
+#include <rnexecutorch/TypeConcepts.h>
 #include <rnexecutorch/models/object_detection/Constants.h>
 #include <rnexecutorch/models/object_detection/Utils.h>
 
@@ -17,9 +22,12 @@ using namespace facebook;
 
 template <typename T> T getValue(const jsi::Value &val, jsi::Runtime &runtime);
 
-template <>
-inline double getValue<double>(const jsi::Value &val, jsi::Runtime &runtime) {
-  return val.asNumber();
+template <typename T>
+  requires IsNumeric<T>
+inline T getValue(const jsi::Value &val, jsi::Runtime &runtime) {
+  static_assert(std::is_integral<T>::value || std::is_floating_point<T>::value,
+                "Only integral and floating-point types are supported");
+  return static_cast<T>(val.asNumber());
 }
 
 template <>
@@ -33,6 +41,78 @@ inline std::string getValue<std::string>(const jsi::Value &val,
   return val.getString(runtime).utf8(runtime);
 }
 
+template <>
+inline JSTensorViewIn getValue<JSTensorViewIn>(const jsi::Value &val,
+                                               jsi::Runtime &runtime) {
+  jsi::Object obj = val.asObject(runtime);
+  JSTensorViewIn tensorView;
+
+  int scalarTypeInt = obj.getProperty(runtime, "scalarType").asNumber();
+  tensorView.scalarType = static_cast<ScalarType>(scalarTypeInt);
+
+  jsi::Value shapeValue = obj.getProperty(runtime, "sizes");
+  jsi::Array shapeArray = shapeValue.asObject(runtime).asArray(runtime);
+  size_t numShapeDims = shapeArray.size(runtime);
+  tensorView.sizes.reserve(numShapeDims);
+
+  for (size_t i = 0; i < numShapeDims; ++i) {
+    int dim = getValue<int>(shapeArray.getValueAtIndex(runtime, i), runtime);
+    tensorView.sizes.push_back(static_cast<int32_t>(dim));
+  }
+
+  // On JS side, TensorPtr objects hold a 'data' property which should be either
+  // an ArrayBuffer or TypedArray
+  jsi::Value dataValue = obj.getProperty(runtime, "dataPtr");
+  jsi::Object dataObj = dataValue.asObject(runtime);
+
+  // Check if it's an ArrayBuffer or TypedArray
+  if (dataObj.isArrayBuffer(runtime)) {
+    jsi::ArrayBuffer arrayBuffer = dataObj.getArrayBuffer(runtime);
+    tensorView.dataPtr = arrayBuffer.data(runtime);
+
+  } else {
+    // Handle typed arrays (Float32Array, Int32Array, etc.)
+    const bool isValidTypedArray = dataObj.hasProperty(runtime, "buffer") &&
+                                   dataObj.hasProperty(runtime, "byteOffset") &&
+                                   dataObj.hasProperty(runtime, "byteLength") &&
+                                   dataObj.hasProperty(runtime, "length");
+    if (!isValidTypedArray) {
+      throw jsi::JSError(runtime, "Data must be an ArrayBuffer or TypedArray");
+    }
+    jsi::Value bufferValue = dataObj.getProperty(runtime, "buffer");
+    if (!bufferValue.isObject() ||
+        !bufferValue.asObject(runtime).isArrayBuffer(runtime)) {
+      throw jsi::JSError(runtime,
+                         "TypedArray buffer property must be an ArrayBuffer");
+    }
+
+    jsi::ArrayBuffer arrayBuffer =
+        bufferValue.asObject(runtime).getArrayBuffer(runtime);
+    size_t byteOffset =
+        getValue<int>(dataObj.getProperty(runtime, "byteOffset"), runtime);
+
+    tensorView.dataPtr =
+        static_cast<uint8_t *>(arrayBuffer.data(runtime)) + byteOffset;
+  }
+  return tensorView;
+}
+
+template <>
+inline std::vector<JSTensorViewIn>
+getValue<std::vector<JSTensorViewIn>>(const jsi::Value &val,
+                                      jsi::Runtime &runtime) {
+  jsi::Array array = val.asObject(runtime).asArray(runtime);
+  size_t length = array.size(runtime);
+  std::vector<JSTensorViewIn> result;
+  result.reserve(length);
+
+  for (size_t i = 0; i < length; ++i) {
+    jsi::Value element = array.getValueAtIndex(runtime, i);
+    result.push_back(getValue<JSTensorViewIn>(element, runtime));
+  }
+  return result;
+}
+
 template <>
 inline std::vector<std::string>
 getValue<std::vector<std::string>>(const jsi::Value &val,
@@ -78,6 +158,51 @@ inline jsi::Value getJsiValue(std::shared_ptr<jsi::Object> valuePtr,
   return std::move(*valuePtr);
 }
 
+inline jsi::Value getJsiValue(const std::vector<int32_t> &vec,
+                              jsi::Runtime &runtime) {
+  jsi::Array array(runtime, vec.size());
+  for (size_t i = 0; i < vec.size(); i++) {
+    array.setValueAtIndex(runtime, i, jsi::Value(static_cast<int>(vec[i])));
+  }
+  return jsi::Value(runtime, array);
+}
+
+inline jsi::Value getJsiValue(int val, jsi::Runtime &runtime) {
+  return jsi::Value(runtime, val);
+}
+
+inline jsi::Value
+getJsiValue(const std::vector<std::shared_ptr<OwningArrayBuffer>> &vec,
+            jsi::Runtime &runtime) {
+  jsi::Array array(runtime, vec.size());
+  for (size_t i = 0; i < vec.size(); i++) {
+    jsi::ArrayBuffer arrayBuffer(runtime, vec[i]);
+    array.setValueAtIndex(runtime, i, jsi::Value(runtime, arrayBuffer));
+  }
+  return jsi::Value(runtime, array);
+}
+
+inline jsi::Value
+getJsiValue(const std::vector<std::shared_ptr<JSTensorViewOut>> &vec,
+            jsi::Runtime &runtime) {
+  jsi::Array array(runtime, vec.size());
+  for (size_t i = 0; i < vec.size(); i++) {
+    jsi::Object tensorObj(runtime);
+
+    tensorObj.setProperty(runtime, "sizes",
+                          getJsiValue(vec[i]->sizes, runtime));
+
+    tensorObj.setProperty(runtime, "scalarType",
+                          jsi::Value(static_cast<int>(vec[i]->scalarType)));
+
+    jsi::ArrayBuffer arrayBuffer(runtime, vec[i]->dataPtr);
+    tensorObj.setProperty(runtime, "dataPtr", arrayBuffer);
+
+    array.setValueAtIndex(runtime, i, tensorObj);
+  }
+  return jsi::Value(runtime, array);
+}
+
 inline jsi::Value getJsiValue(const std::string &str, jsi::Runtime &runtime) {
   return jsi::String::createFromAscii(runtime, str);
 }

packages/react-native-executorch/common/rnexecutorch/host_objects/ModelHostObject.h

@@ -8,10 +8,12 @@
 #include <ReactCommon/CallInvoker.h>
 
 #include <rnexecutorch/Log.h>
-#include <rnexecutorch/TypeConstraints.h>
+#include <rnexecutorch/TypeConcepts.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/models/BaseModel.h>
 
 namespace rnexecutorch {
 
@@ -20,13 +22,28 @@ template <typename Model> class ModelHostObject : public JsiHostObject {
   explicit ModelHostObject(const std::shared_ptr<Model> &model,
                            std::shared_ptr<react::CallInvoker> callInvoker)
       : model(model), callInvoker(callInvoker) {
-    addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                     promiseHostFunction<&Model::forward>,
-                                     "forward"));
-    if constexpr (DerivedFromBaseModel<Model>) {
+    if constexpr (DerivedFromOrSameAs<Model, BaseModel>) {
       addFunctions(
           JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
     }
+
+    if constexpr (DerivedFromOrSameAs<Model, BaseModel>) {
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::forwardJS>,
+                                       "forward"));
+    }
+
+    if constexpr (DerivedFromOrSameAs<Model, BaseModel>) {
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>, promiseHostFunction<&Model::getInputShape>,
+          "getInputShape"));
+    }
+
+    if constexpr (HasGenerate<Model>) {
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::generate>,
+                                       "generate"));
+    }
   }
 
   // A generic host function that resolves a promise with a result of a