expo-modules-core 0.9.2 → 0.11.1

package/android/src/main/cpp/JSITypeConverter.h

@@ -0,0 +1,84 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include "JSIObjectWrapper.h"
+
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+
+#include <type_traits>
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+
+namespace expo {
+/**
+ * A base template of the jni to jsi types converter.
+ * To make this conversion as fast and easy as possible we used the type trait technic.
+ */
+template<class T, typename = void>
+struct jsi_type_converter {
+  static const bool isDefined = false;
+};
+
+/**
+ * Conversion from jni::alias_ref<T::javaobject> to jsi::Value where T extends JSIValueWrapper or JSIObjectWrapper.
+ */
+template<class T>
+struct jsi_type_converter<
+  jni::alias_ref<T>,
+  std::enable_if_t<
+    // jni::ReprType<T>::HybridType>::value if T looks like `R::javaobject`, it will return R
+    std::is_base_of<JSIValueWrapper, typename jni::ReprType<T>::HybridType>::value ||
+    std::is_base_of<JSIObjectWrapper, typename jni::ReprType<T>::HybridType>::value
+  >
+> {
+  static const bool isDefined = true;
+
+  inline static jsi::Value convert(
+    jsi::Runtime &runtime,
+    jni::alias_ref<T> &value) {
+    if (value == nullptr) {
+      return jsi::Value::undefined();
+    }
+    return jsi::Value(runtime, *value->cthis()->get());
+  }
+};
+
+/**
+ * Conversion from primitive types from which jsi::Value can be constructed (like bool, double) to jsi::Value.
+ */
+template<class T>
+struct jsi_type_converter<
+  T,
+  std::enable_if_t<std::is_fundamental_v<T> && std::is_constructible_v<jsi::Value, T>>
+> {
+  static const bool isDefined = true;
+
+  inline static jsi::Value convert(jsi::Runtime &runtime, T value) {
+    return jsi::Value(value);
+  }
+};
+
+/**
+ * Conversion from jni::alias_ref<jstring> to jsi::Value.
+ */
+template<>
+struct jsi_type_converter<jni::alias_ref<jstring>> {
+  static const bool isDefined = true;
+
+  inline static jsi::Value convert(jsi::Runtime &runtime, jni::alias_ref<jstring> &value) {
+    if (value == nullptr) {
+      return jsi::Value::undefined();
+    }
+    return jsi::Value(jsi::String::createFromUtf8(runtime, value->toStdString()));
+  }
+};
+
+/**
+ * Helper that checks if the type converter was defined for the given type.
+ */
+template<class T>
+inline constexpr bool is_jsi_type_converter_defined = jsi_type_converter<T>::isDefined;
+} // namespace expo

package/android/src/main/cpp/JavaScriptModuleObject.cpp

@@ -0,0 +1,219 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "JavaScriptModuleObject.h"
+#include "JSIInteropModuleRegistry.h"
+
+#include <folly/dynamic.h>
+#include <jsi/JSIDynamic.h>
+#include <react/jni/ReadableNativeArray.h>
+#include <fbjni/detail/Hybrid.h>
+#include <ReactCommon/TurboModuleUtils.h>
+#include <jni/JCallback.h>
+#include <jsi/JSIDynamic.h>
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+
+#include <utility>
+#include <tuple>
+#include <algorithm>
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+namespace expo {
+
+jni::local_ref<jni::HybridClass<JavaScriptModuleObject>::jhybriddata>
+JavaScriptModuleObject::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+void JavaScriptModuleObject::registerNatives() {
+  registerHybrid({
+                   makeNativeMethod("initHybrid", JavaScriptModuleObject::initHybrid),
+                   makeNativeMethod("exportConstants", JavaScriptModuleObject::exportConstants),
+                   makeNativeMethod("registerSyncFunction",
+                                    JavaScriptModuleObject::registerSyncFunction),
+                   makeNativeMethod("registerAsyncFunction",
+                                    JavaScriptModuleObject::registerAsyncFunction),
+                   makeNativeMethod("registerProperty",
+                                    JavaScriptModuleObject::registerProperty),
+                 });
+}
+
+std::shared_ptr<jsi::Object> JavaScriptModuleObject::getJSIObject(jsi::Runtime &runtime) {
+  if (jsiObject == nullptr) {
+    auto hostObject = std::make_shared<JavaScriptModuleObject::HostObject>(this);
+    jsiObject = std::make_shared<jsi::Object>(
+      jsi::Object::createFromHostObject(runtime, hostObject));
+  }
+
+  return jsiObject;
+}
+
+void JavaScriptModuleObject::exportConstants(
+  jni::alias_ref<react::NativeMap::javaobject> constants
+) {
+  auto dynamic = constants->cthis()->consume();
+  assert(dynamic.isObject());
+
+  for (const auto &[key, value]: dynamic.items()) {
+    this->constants[key.asString()] = value;
+  }
+}
+
+void JavaScriptModuleObject::registerSyncFunction(
+  jni::alias_ref<jstring> name,
+  jint args,
+  jni::alias_ref<jni::JArrayInt> desiredTypes,
+  jni::alias_ref<JNIFunctionBody::javaobject> body
+) {
+  std::string cName = name->toStdString();
+  std::unique_ptr<int[]> types = desiredTypes->getRegion(0, args);
+
+  methodsMetadata.try_emplace(
+    cName,
+    cName,
+    args,
+    false,
+    std::move(types),
+    jni::make_global(body)
+  );
+}
+
+void JavaScriptModuleObject::registerAsyncFunction(
+  jni::alias_ref<jstring> name,
+  jint args,
+  jni::alias_ref<jni::JArrayInt> desiredTypes,
+  jni::alias_ref<JNIAsyncFunctionBody::javaobject> body
+) {
+  auto cName = name->toStdString();
+  std::unique_ptr<int[]> types = desiredTypes->getRegion(0, args);
+
+  methodsMetadata.try_emplace(
+    cName,
+    cName,
+    args,
+    true,
+    std::move(types),
+    jni::make_global(body)
+  );
+}
+
+void JavaScriptModuleObject::registerProperty(
+  jni::alias_ref<jstring> name,
+  jint desiredType,
+  jni::alias_ref<JNIFunctionBody::javaobject> getter,
+  jni::alias_ref<JNIFunctionBody::javaobject> setter
+) {
+  auto cName = name->toStdString();
+  std::unique_ptr<int[]> types = std::make_unique<int[]>(1);
+  types[0] = desiredType;
+
+  auto getterMetadata = MethodMetadata(
+    cName,
+    0,
+    false,
+    std::make_unique<int[]>(0),
+    jni::make_global(getter)
+  );
+
+  auto setterMetadata = MethodMetadata(
+    cName,
+    1,
+    false,
+    std::move(types),
+    jni::make_global(setter)
+  );
+
+  auto functions = std::make_pair(
+    std::move(getterMetadata),
+    std::move(setterMetadata)
+  );
+
+  properties.insert({cName, std::move(functions)});
+}
+
+JavaScriptModuleObject::HostObject::HostObject(
+  JavaScriptModuleObject *jsModule) : jsModule(jsModule) {}
+
+jsi::Value JavaScriptModuleObject::HostObject::get(jsi::Runtime &runtime,
+                                                   const jsi::PropNameID &name) {
+  auto cName = name.utf8(runtime);
+
+  auto constantsRecord = jsModule->constants.find(cName);
+  if (constantsRecord != jsModule->constants.end()) {
+    auto dynamic = constantsRecord->second;
+    return jsi::valueFromDynamic(runtime, dynamic);
+  }
+
+  auto propertyRecord = jsModule->properties.find(cName);
+  if (propertyRecord != jsModule->properties.end()) {
+    auto&[getter, _] = propertyRecord->second;
+    return getter.callSync(runtime, jsModule->jsiInteropModuleRegistry, nullptr, 0);
+  }
+
+  auto metadataRecord = jsModule->methodsMetadata.find(cName);
+  if (metadataRecord == jsModule->methodsMetadata.end()) {
+    return jsi::Value::undefined();
+  }
+  auto &metadata = metadataRecord->second;
+  return jsi::Value(runtime, *metadata.toJSFunction(runtime, jsModule->jsiInteropModuleRegistry));
+}
+
+void JavaScriptModuleObject::HostObject::set(
+  jsi::Runtime &runtime,
+  const jsi::PropNameID &name,
+  const jsi::Value &value
+) {
+  auto cName = name.utf8(runtime);
+  auto propertyRecord = jsModule->properties.find(cName);
+  if (propertyRecord != jsModule->properties.end()) {
+    auto&[_, setter] = propertyRecord->second;
+    setter.callSync(runtime, jsModule->jsiInteropModuleRegistry, &value, 1);
+    return;
+  }
+
+  throw jsi::JSError(
+    runtime,
+    "RuntimeError: Cannot override the host object for expo module '" + name.utf8(runtime) + "'"
+  );
+}
+
+std::vector<jsi::PropNameID> JavaScriptModuleObject::HostObject::getPropertyNames(
+  jsi::Runtime &rt
+) {
+  auto &metadata = jsModule->methodsMetadata;
+  std::vector<jsi::PropNameID> result;
+  std::transform(
+    metadata.begin(),
+    metadata.end(),
+    std::back_inserter(result),
+    [&rt](const auto &kv) {
+      return jsi::PropNameID::forUtf8(rt, kv.first);
+    }
+  );
+
+  auto &constants = jsModule->constants;
+  std::transform(
+    constants.begin(),
+    constants.end(),
+    std::back_inserter(result),
+    [&rt](const auto &kv) {
+      return jsi::PropNameID::forUtf8(rt, kv.first);
+    }
+  );
+
+  auto &properties = jsModule->properties;
+  std::transform(
+    properties.begin(),
+    properties.end(),
+    std::back_inserter(result),
+    [&rt](const auto &kv) {
+      return jsi::PropNameID::forUtf8(rt, kv.first);
+    }
+  );
+
+  return result;
+}
+} // namespace expo

package/android/src/main/cpp/JavaScriptModuleObject.h

@@ -0,0 +1,144 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <react/jni/ReadableNativeArray.h>
+#include <jni/JCallback.h>
+
+#include <unordered_map>
+
+#include "MethodMetadata.h"
+#include "JNIFunctionBody.h"
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+namespace expo {
+class JSIInteropModuleRegistry;
+
+/**
+ * A CPP part of the module.
+ *
+ * Right now objects of this class are stored by the ModuleHolder to ensure they will live
+ * as long as the RN context.
+ */
+class JavaScriptModuleObject : public jni::HybridClass<JavaScriptModuleObject> {
+public:
+  static auto constexpr
+    kJavaDescriptor = "Lexpo/modules/kotlin/jni/JavaScriptModuleObject;";
+  static auto constexpr TAG = "JavaScriptModuleObject";
+
+  static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+
+  static void registerNatives();
+
+  /**
+   * Pointer to the module registry interop.
+   */
+  JSIInteropModuleRegistry *jsiInteropModuleRegistry;
+
+  /**
+   * Returns a cached instance of jsi::Object representing this module.
+   * @param runtime
+   * @return Wrapped instance of JavaScriptModuleObject::HostObject
+   */
+  std::shared_ptr<jsi::Object> getJSIObject(jsi::Runtime &runtime);
+
+  /**
+   * Exports constants that will be assigned to the underlying HostObject.
+   */
+  void exportConstants(jni::alias_ref<react::NativeMap::javaobject> constants);
+
+  /**
+   * Registers a sync function.
+   * That function can be called via the `JavaScriptModuleObject.callSyncMethod` method.
+   */
+  void registerSyncFunction(
+    jni::alias_ref<jstring> name,
+    jint args,
+    jni::alias_ref<jni::JArrayInt> desiredTypes,
+    jni::alias_ref<JNIFunctionBody::javaobject> body
+  );
+
+  /**
+   * Registers a async function.
+   * That function can be called via the `JavaScriptModuleObject.callAsyncMethod` method.
+   */
+  void registerAsyncFunction(
+    jni::alias_ref<jstring> name,
+    jint args,
+    jni::alias_ref<jni::JArrayInt> desiredTypes,
+    jni::alias_ref<JNIAsyncFunctionBody::javaobject> body
+  );
+
+  /**
+   * Registers a property
+   * @param name of the property
+   * @param desiredType of the setter argument
+   * @param getter body for the get method - can be nullptr
+   * @param setter body for the set method - can be nullptr
+   */
+  void registerProperty(
+    jni::alias_ref<jstring> name,
+    jint desiredType,
+    jni::alias_ref<JNIFunctionBody::javaobject> getter,
+    jni::alias_ref<JNIFunctionBody::javaobject> setter
+  );
+
+  /**
+   * An inner class of the `JavaScriptModuleObject` that is exported to the JS.
+   * It's an additional communication layer between JS and Kotlin.
+   * So the high-level view on accessing the exported function will look like this:
+   * `JS` --get function--> `JavaScriptModuleObject::HostObject` --access module metadata--> `JavaScriptModuleObject`
+   *  --create JSI function--> `MethodMetadata`
+   *
+   * This abstraction wasn't necessary. However, it makes the management of ownership much easier -
+   * `JavaScriptModuleObject` is held by the ModuleHolder and `JavaScriptModuleObject::HostObject` is stored in the JS runtime.
+   * Without this distinction the `JavaScriptModuleObject` would have to turn into `HostObject` and `HybridObject` at the same time.
+   */
+  class HostObject : public jsi::HostObject {
+  public:
+    HostObject(JavaScriptModuleObject *);
+
+    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+
+    void set(jsi::Runtime &, const jsi::PropNameID &name, const jsi::Value &value) override;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  private:
+    JavaScriptModuleObject *jsModule;
+  };
+
+private:
+  friend HybridBase;
+  /**
+   * A reference to the `JavaScriptModuleObject::HostObject`.
+   * Simple we cached that value to return the same object each time.
+   */
+  std::shared_ptr<jsi::Object> jsiObject = nullptr;
+  jni::global_ref<JavaScriptModuleObject::javaobject> javaPart_;
+
+  /**
+   * Metadata map that stores information about all available methods on this module.
+   */
+  std::unordered_map<std::string, MethodMetadata> methodsMetadata;
+
+  /**
+   * A constants map.
+   */
+  std::unordered_map<std::string, folly::dynamic> constants;
+
+  /**
+   * A registry of properties
+   * The first MethodMetadata points to the getter and the second one to the setter.
+   */
+  std::map<std::string, std::pair<MethodMetadata, MethodMetadata>> properties;
+
+  explicit JavaScriptModuleObject(jni::alias_ref<jhybridobject> jThis)
+    : javaPart_(jni::make_global(jThis)) {}
+};
+} // namespace expo

package/android/src/main/cpp/JavaScriptObject.cpp

@@ -0,0 +1,125 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "JavaScriptObject.h"
+#include "JavaScriptValue.h"
+#include "JavaScriptRuntime.h"
+#include "JSITypeConverter.h"
+
+namespace expo {
+void JavaScriptObject::registerNatives() {
+  registerHybrid({
+                   makeNativeMethod("hasProperty", JavaScriptObject::jniHasProperty),
+                   makeNativeMethod("getProperty", JavaScriptObject::jniGetProperty),
+                   makeNativeMethod("getPropertyNames", JavaScriptObject::jniGetPropertyNames),
+                   makeNativeMethod("setBoolProperty", JavaScriptObject::setProperty<bool>),
+                   makeNativeMethod("setDoubleProperty", JavaScriptObject::setProperty<double>),
+                   makeNativeMethod("setStringProperty",
+                                    JavaScriptObject::setProperty<jni::alias_ref<jstring>>),
+                   makeNativeMethod("setJSValueProperty",
+                                    JavaScriptObject::setProperty<jni::alias_ref<JavaScriptValue::javaobject>>),
+                   makeNativeMethod("setJSObjectProperty",
+                                    JavaScriptObject::setProperty<jni::alias_ref<JavaScriptObject::javaobject>>),
+                   makeNativeMethod("unsetProperty", JavaScriptObject::unsetProperty),
+                   makeNativeMethod("defineBoolProperty", JavaScriptObject::defineProperty<bool>),
+                   makeNativeMethod("defineDoubleProperty",
+                                    JavaScriptObject::defineProperty<double>),
+                   makeNativeMethod("defineStringProperty",
+                                    JavaScriptObject::defineProperty<jni::alias_ref<jstring>>),
+                   makeNativeMethod("defineJSValueProperty",
+                                    JavaScriptObject::defineProperty<jni::alias_ref<JavaScriptValue::javaobject>>),
+                   makeNativeMethod("defineJSObjectProperty",
+                                    JavaScriptObject::defineProperty<jni::alias_ref<JavaScriptObject::javaobject>>),
+                 });
+}
+
+JavaScriptObject::JavaScriptObject(
+  std::weak_ptr<JavaScriptRuntime> runtime,
+  std::shared_ptr<jsi::Object> jsObject
+) : runtimeHolder(std::move(runtime)), jsObject(std::move(jsObject)) {
+  assert(runtimeHolder.lock() != nullptr);
+}
+
+std::shared_ptr<jsi::Object> JavaScriptObject::get() {
+  return jsObject;
+}
+
+bool JavaScriptObject::hasProperty(const std::string &name) {
+  auto runtime = runtimeHolder.lock();
+  assert(runtime != nullptr);
+  return jsObject->hasProperty(*runtime->get(), name.c_str());
+}
+
+jsi::Value JavaScriptObject::getProperty(const std::string &name) {
+  auto runtime = runtimeHolder.lock();
+  assert(runtime != nullptr);
+  return jsObject->getProperty(*runtime->get(), name.c_str());
+}
+
+bool JavaScriptObject::jniHasProperty(jni::alias_ref<jstring> name) {
+  return hasProperty(name->toStdString());
+}
+
+jni::local_ref<JavaScriptValue::javaobject> JavaScriptObject::jniGetProperty(
+  jni::alias_ref<jstring> name
+) {
+  auto result = std::make_shared<jsi::Value>(getProperty(name->toStdString()));
+  return JavaScriptValue::newObjectCxxArgs(runtimeHolder, result);
+}
+
+std::vector<std::string> JavaScriptObject::getPropertyNames() {
+  auto runtime = runtimeHolder.lock();
+  assert(runtime != nullptr);
+
+  jsi::Array properties = jsObject->getPropertyNames(*runtime->get());
+  auto size = properties.size(*runtime->get());
+
+  std::vector<std::string> names(size);
+  for (size_t i = 0; i < size; i++) {
+    auto propertyName = properties
+      .getValueAtIndex(*runtime->get(), i)
+      .asString(*runtime->get())
+      .utf8(*runtime->get());
+    names[i] = propertyName;
+  }
+
+  return names;
+}
+
+jni::local_ref<jni::JArrayClass<jstring>> JavaScriptObject::jniGetPropertyNames() {
+  std::vector<std::string> cResult = getPropertyNames();
+  auto paredResult = jni::JArrayClass<jstring>::newArray(cResult.size());
+  for (size_t i = 0; i < cResult.size(); i++) {
+    paredResult->setElement(i, jni::make_jstring(cResult[i]).get());
+  }
+
+  return paredResult;
+}
+
+void JavaScriptObject::setProperty(const std::string &name, jsi::Value value) {
+  auto runtime = runtimeHolder.lock();
+  assert(runtime != nullptr);
+  jsObject->setProperty(*runtime->get(), name.c_str(), value);
+}
+
+void JavaScriptObject::unsetProperty(jni::alias_ref<jstring> name) {
+  auto runtime = runtimeHolder.lock();
+  assert(runtime != nullptr);
+  auto cName = name->toStdString();
+  jsObject->setProperty(
+    *runtime->get(),
+    cName.c_str(),
+    jsi::Value::undefined()
+  );
+}
+
+jsi::Object JavaScriptObject::preparePropertyDescriptor(
+  jsi::Runtime &jsRuntime,
+  int options
+) {
+  jsi::Object descriptor(jsRuntime);
+  descriptor.setProperty(jsRuntime, "configurable", (bool) ((1 << 0) & options));
+  descriptor.setProperty(jsRuntime, "enumerable", (bool) ((1 << 1) & options));
+  descriptor.setProperty(jsRuntime, "writable", (bool) ((1 << 2) & options));
+  return descriptor;
+}
+} // namespace expo

package/android/src/main/cpp/JavaScriptObject.h

@@ -0,0 +1,131 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include "JSIObjectWrapper.h"
+#include "JSITypeConverter.h"
+#include "JavaScriptRuntime.h"
+
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+
+#include <memory>
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+
+namespace expo {
+class JavaScriptValue;
+
+class JavaScriptRuntime;
+
+/**
+ * Represents any JavaScript object. Its purpose is to exposes `jsi::Object` API back to Kotlin.
+ */
+class JavaScriptObject : public jni::HybridClass<JavaScriptObject>, JSIObjectWrapper {
+public:
+  static auto constexpr
+    kJavaDescriptor = "Lexpo/modules/kotlin/jni/JavaScriptObject;";
+  static auto constexpr TAG = "JavaScriptObject";
+
+  static void registerNatives();
+
+  JavaScriptObject(
+    std::weak_ptr<JavaScriptRuntime> runtime,
+    std::shared_ptr<jsi::Object> jsObject
+  );
+
+  std::shared_ptr<jsi::Object> get() override;
+
+  /**
+   * @return a bool whether the object has a property with the given name
+   */
+  bool hasProperty(const std::string &name);
+
+  /**
+   * @return the property of the object with the given name.
+   * If the name isn't a property on the object, returns the `jsi::Value::undefined` value.
+   */
+  jsi::Value getProperty(const std::string &name);
+
+  /**
+   * @return a vector consisting of all enumerable property names in the object and its prototype chain.
+   */
+  std::vector<std::string> getPropertyNames();
+
+  void setProperty(const std::string &name, jsi::Value value);
+
+private:
+  friend HybridBase;
+  std::weak_ptr<JavaScriptRuntime> runtimeHolder;
+  std::shared_ptr<jsi::Object> jsObject;
+
+  bool jniHasProperty(jni::alias_ref<jstring> name);
+
+  jni::local_ref<jni::HybridClass<JavaScriptValue>::javaobject> jniGetProperty(
+    jni::alias_ref<jstring> name
+  );
+
+  jni::local_ref<jni::JArrayClass<jstring>> jniGetPropertyNames();
+
+  /**
+   * Unsets property with the given name.
+   */
+  void unsetProperty(jni::alias_ref<jstring> name);
+
+  /**
+   * A template to generate different versions of the `setProperty` method based on the `jsi_type_converter` trait.
+   * Those generated methods will be exported and visible in the Kotlin codebase.
+   * On the other hand, we could just make one function that would take a generic Java Object,
+   * but then we would have to decide what to do with it and how to convert it to jsi::Value
+   * in cpp. That would be expensive. So it's easier to ensure that
+   * we call the correct version of `setProperty` in the Kotlin code.
+   *
+   * This template will work only if the jsi_type_converter exists for a given type.
+   */
+  template<
+    class T,
+    typename = std::enable_if_t<is_jsi_type_converter_defined<T>>
+  >
+  void setProperty(jni::alias_ref<jstring> name, T value) {
+    auto runtime = runtimeHolder.lock();
+    assert(runtime != nullptr);
+    auto cName = name->toStdString();
+
+    jsObject->setProperty(
+      *runtime->get(),
+      cName.c_str(),
+      jsi_type_converter<T>::convert(*runtime->get(), value)
+    );
+  }
+
+  template<
+    class T,
+    typename = std::enable_if_t<is_jsi_type_converter_defined<T>>
+  >
+  void defineProperty(jni::alias_ref<jstring> name, T value, int options) {
+    auto runtime = runtimeHolder.lock();
+    assert(runtime != nullptr);
+    jsi::Runtime &jsRuntime = *runtime->get();
+
+    auto cName = name->toStdString();
+    jsi::Object global = jsRuntime.global();
+    jsi::Object objectClass = global.getPropertyAsObject(jsRuntime, "Object");
+    jsi::Function definePropertyFunction = objectClass.getPropertyAsFunction(
+      jsRuntime,
+      "defineProperty"
+    );
+    jsi::Object descriptor = preparePropertyDescriptor(jsRuntime, options);
+
+    descriptor.setProperty(jsRuntime, "value", jsi_type_converter<T>::convert(jsRuntime, value));
+
+    definePropertyFunction.callWithThis(jsRuntime, objectClass, {
+      jsi::Value(jsRuntime, *jsObject),
+      jsi::String::createFromUtf8(jsRuntime, cName),
+      std::move(descriptor)
+    });
+  }
+
+  static jsi::Object preparePropertyDescriptor(jsi::Runtime &jsRuntime, int options);
+};
+} // namespace expo