expo-modules-core 0.9.0 → 0.10.0

package/android/src/main/cpp/JNIFunctionBody.cpp

@@ -0,0 +1,29 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "JNIFunctionBody.h"
+
+namespace jni = facebook::jni;
+namespace react = facebook::react;
+
+namespace expo {
+jni::local_ref<react::ReadableNativeArray::javaobject>
+JNIFunctionBody::invoke(react::ReadableNativeArray::javaobject &&args) {
+  static const auto method = getClass()->getMethod<
+    react::ReadableNativeArray::javaobject(react::ReadableNativeArray::javaobject)
+  >(
+    "invoke"
+  );
+
+  return method(this->self(), args);
+}
+
+void JNIAsyncFunctionBody::invoke(react::ReadableNativeArray::javaobject &&args, jobject promise) {
+  static const auto method = getClass()->getMethod<
+    void(react::ReadableNativeArray::javaobject, jobject)
+  >(
+    "invoke"
+  );
+
+  method(this->self(), args, promise);
+}
+} // namespace expo

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

@@ -0,0 +1,50 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/jni/ReadableNativeArray.h>
+
+namespace jni = facebook::jni;
+namespace react = facebook::react;
+
+namespace expo {
+/**
+ * A CPP part of the expo.modules.kotlin.jni.JNIFunctionBody class.
+ * It represents the Kotlin's promise-less function.
+ */
+class JNIFunctionBody : public jni::JavaClass<JNIFunctionBody> {
+public:
+  static auto constexpr kJavaDescriptor = "Lexpo/modules/kotlin/jni/JNIFunctionBody;";
+
+  /**
+   * Invokes a Kotlin's implementation of this function.
+   *
+   * @param args
+   * @return result of the Kotlin function
+   */
+  jni::local_ref<react::ReadableNativeArray::javaobject> invoke(
+    react::ReadableNativeArray::javaobject &&args
+  );
+};
+
+/**
+ * A CPP part of the expo.modules.kotlin.jni.JNIAsyncFunctionBody class.
+ * It represents the Kotlin's promise function.
+ */
+class JNIAsyncFunctionBody : public jni::JavaClass<JNIAsyncFunctionBody> {
+public:
+  static auto constexpr kJavaDescriptor = "Lexpo/modules/kotlin/jni/JNIAsyncFunctionBody;";
+
+  /**
+   * Invokes a Kotlin's implementation of this async function.
+   *
+   * @param args
+   * @param promise that will be resolve or rejected in the Kotlin's implementation
+   */
+  void invoke(
+    react::ReadableNativeArray::javaobject &&args,
+    jobject promise
+  );
+};
+} // namespace expo

package/android/src/main/cpp/JNIInjector.cpp

@@ -0,0 +1,19 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "JSIInteropModuleRegistry.h"
+#include "JavaScriptModuleObject.h"
+#include "JavaScriptValue.h"
+#include "JavaScriptObject.h"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+
+// Install all jni bindings
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
+  return facebook::jni::initialize(vm, [] {
+    expo::JSIInteropModuleRegistry::registerNatives();
+    expo::JavaScriptModuleObject::registerNatives();
+    expo::JavaScriptValue::registerNatives();
+    expo::JavaScriptObject::registerNatives();
+  });
+}

package/android/src/main/cpp/JSIInteropModuleRegistry.cpp

@@ -0,0 +1,122 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "JSIInteropModuleRegistry.h"
+#include "ExpoModulesHostObject.h"
+
+#include <fbjni/detail/Meta.h>
+#include <fbjni/fbjni.h>
+
+#include <memory>
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+
+namespace expo {
+jni::local_ref<JSIInteropModuleRegistry::jhybriddata>
+JSIInteropModuleRegistry::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+void JSIInteropModuleRegistry::registerNatives() {
+  registerHybrid({
+                   makeNativeMethod("initHybrid", JSIInteropModuleRegistry::initHybrid),
+                   makeNativeMethod("installJSI", JSIInteropModuleRegistry::installJSI),
+                   makeNativeMethod("installJSIForTests",
+                                    JSIInteropModuleRegistry::installJSIForTests),
+                   makeNativeMethod("evaluateScript", JSIInteropModuleRegistry::evaluateScript),
+                   makeNativeMethod("global", JSIInteropModuleRegistry::global),
+                   makeNativeMethod("createObject", JSIInteropModuleRegistry::createObject),
+                   makeNativeMethod("drainJSEventLoop", JSIInteropModuleRegistry::drainJSEventLoop),
+                 });
+}
+
+JSIInteropModuleRegistry::JSIInteropModuleRegistry(jni::alias_ref<jhybridobject> jThis)
+  : javaPart_(jni::make_global(jThis)) {}
+
+void JSIInteropModuleRegistry::installJSI(
+  jlong jsRuntimePointer,
+  jni::alias_ref<react::CallInvokerHolder::javaobject> jsInvokerHolder,
+  jni::alias_ref<react::CallInvokerHolder::javaobject> nativeInvokerHolder
+) {
+  auto runtime = reinterpret_cast<jsi::Runtime *>(jsRuntimePointer);
+  runtimeHolder = std::make_shared<JavaScriptRuntime>(
+    runtime,
+    jsInvokerHolder->cthis()->getCallInvoker(),
+    nativeInvokerHolder->cthis()->getCallInvoker()
+  );
+
+  auto expoModules = std::make_shared<ExpoModulesHostObject>(this);
+  auto expoModulesObject = jsi::Object::createFromHostObject(*runtime, expoModules);
+
+  runtime
+    ->global()
+    .setProperty(
+      *runtime,
+      "ExpoModules",
+      std::move(expoModulesObject)
+    );
+}
+
+void JSIInteropModuleRegistry::installJSIForTests() {
+  runtimeHolder = std::make_shared<JavaScriptRuntime>();
+  jsi::Runtime &jsiRuntime = *runtimeHolder->get();
+
+  auto expoModules = std::make_shared<ExpoModulesHostObject>(this);
+  auto expoModulesObject = jsi::Object::createFromHostObject(jsiRuntime, expoModules);
+
+  jsiRuntime
+    .global()
+    .setProperty(
+      jsiRuntime,
+      "ExpoModules",
+      std::move(expoModulesObject)
+    );
+}
+
+jni::local_ref<JavaScriptModuleObject::javaobject>
+JSIInteropModuleRegistry::callGetJavaScriptModuleObjectMethod(const std::string &moduleName) const {
+  const static auto method = expo::JSIInteropModuleRegistry::javaClassLocal()
+    ->getMethod<jni::local_ref<JavaScriptModuleObject::javaobject>(
+      std::string)>(
+      "getJavaScriptModuleObject"
+    );
+
+  return method(javaPart_, moduleName);
+}
+
+jni::local_ref<jni::JArrayClass<jni::JString>>
+JSIInteropModuleRegistry::callGetJavaScriptModulesNames() const {
+  const static auto method = expo::JSIInteropModuleRegistry::javaClassLocal()
+    ->getMethod<jni::local_ref<jni::JArrayClass<jni::JString>>()>(
+      "getJavaScriptModulesName"
+    );
+  return method(javaPart_);
+}
+
+jni::local_ref<JavaScriptModuleObject::javaobject>
+JSIInteropModuleRegistry::getModule(const std::string &moduleName) const {
+  return callGetJavaScriptModuleObjectMethod(moduleName);
+}
+
+jni::local_ref<jni::JArrayClass<jni::JString>> JSIInteropModuleRegistry::getModulesName() const {
+  return callGetJavaScriptModulesNames();
+}
+
+jni::local_ref<JavaScriptValue::javaobject> JSIInteropModuleRegistry::evaluateScript(
+  jni::JString script
+) {
+  return runtimeHolder->evaluateScript(script.toStdString());
+}
+
+jni::local_ref<JavaScriptObject::javaobject> JSIInteropModuleRegistry::global() {
+  return runtimeHolder->global();
+}
+
+jni::local_ref<JavaScriptObject::javaobject> JSIInteropModuleRegistry::createObject() {
+  return runtimeHolder->createObject();
+}
+
+void JSIInteropModuleRegistry::drainJSEventLoop() {
+  runtimeHolder->drainJSEventLoop();
+}
+} // namespace expo

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

@@ -0,0 +1,96 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include "JavaScriptRuntime.h"
+#include "JavaScriptModuleObject.h"
+#include "JavaScriptValue.h"
+#include "JavaScriptObject.h"
+
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvokerHolder.h>
+#include <ReactCommon/CallInvoker.h>
+
+#include <memory>
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+namespace expo {
+/**
+ * A JNI wrapper to initialize CPP part of modules and access all data from the module registry.
+ */
+class JSIInteropModuleRegistry : public jni::HybridClass<JSIInteropModuleRegistry> {
+public:
+  static auto constexpr
+    kJavaDescriptor = "Lexpo/modules/kotlin/jni/JSIInteropModuleRegistry;";
+  static auto constexpr TAG = "JSIInteropModuleRegistry";
+
+  static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+
+  static void registerNatives();
+
+  /**
+   * Initializes the `ExpoModulesHostObject` and adds it to the global object.
+   */
+  void installJSI(
+    jlong jsRuntimePointer,
+    jni::alias_ref<react::CallInvokerHolder::javaobject> jsInvokerHolder,
+    jni::alias_ref<react::CallInvokerHolder::javaobject> nativeInvokerHolder
+  );
+
+  /**
+   * Initializes the test runtime. Shouldn't be used in the production.
+   */
+  void installJSIForTests();
+
+  /**
+   * Gets a module for a given name. It will throw an exception if the module doesn't exist.
+   *
+   * @param moduleName
+   * @return An instance of `JavaScriptModuleObject`
+   */
+  jni::local_ref<JavaScriptModuleObject::javaobject> getModule(const std::string &moduleName) const;
+
+  /**
+   * Gets names of all available modules.
+   */
+  jni::local_ref<jni::JArrayClass<jni::JString>> getModulesName() const;
+
+  /**
+   * Exposes a `JavaScriptRuntime::evaluateScript` function to Kotlin
+   */
+  jni::local_ref<JavaScriptValue::javaobject> evaluateScript(jni::JString script);
+
+  /**
+   * Exposes a `JavaScriptRuntime::global` function to Kotlin
+   */
+  jni::local_ref<JavaScriptObject::javaobject> global();
+
+  /**
+   * Exposes a `JavaScriptRuntime::createObject` function to Kotlin
+   */
+  jni::local_ref<JavaScriptObject::javaobject> createObject();
+
+  /**
+   * Exposes a `JavaScriptRuntime::drainJSEventLoop` function to Kotlin
+   */
+  void drainJSEventLoop();
+
+  std::shared_ptr<react::CallInvoker> jsInvoker;
+  std::shared_ptr<react::CallInvoker> nativeInvoker;
+  std::shared_ptr<JavaScriptRuntime> runtimeHolder;
+private:
+  friend HybridBase;
+  jni::global_ref<JSIInteropModuleRegistry::javaobject> javaPart_;
+
+  explicit JSIInteropModuleRegistry(jni::alias_ref<jhybridobject> jThis);
+
+  inline jni::local_ref<JavaScriptModuleObject::javaobject>
+  callGetJavaScriptModuleObjectMethod(const std::string &moduleName) const;
+
+  inline jni::local_ref<jni::JArrayClass<jni::JString>> callGetJavaScriptModulesNames() const;
+};
+} // namespace expo

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

@@ -0,0 +1,33 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+namespace jsi = facebook::jsi;
+
+namespace expo {
+/**
+ * An interface for classes which wrap jsi::Object.
+ */
+class JSIObjectWrapper {
+public:
+  /**
+   * @return a pointer to the underlying jsi::Object.
+   */
+  virtual std::shared_ptr<jsi::Object> get() = 0;
+};
+
+/**
+ * An interface for classes which wrap jsi::Value.
+ */
+class JSIValueWrapper {
+public:
+  /**
+   * @return a pointer to the underlying jsi::Value.
+   */
+  virtual std::shared_ptr<jsi::Value> get() = 0;
+};
+} // namespace expo

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,138 @@
+// 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),
+                 });
+}
+
+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<JNIFunctionBody::javaobject> body
+) {
+  auto cName = name->toStdString();
+  methodsMetadata.try_emplace(cName, cName, args, false, jni::make_global(body));
+}
+
+void JavaScriptModuleObject::registerAsyncFunction(
+  jni::alias_ref<jstring> name,
+  jint args,
+  jni::alias_ref<JNIAsyncFunctionBody::javaobject> body
+) {
+  auto cName = name->toStdString();
+  methodsMetadata.try_emplace(cName, cName, args, true, jni::make_global(body));
+}
+
+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 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
+) {
+  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);
+    }
+  );
+
+  return result;
+}
+} // namespace expo

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

@@ -0,0 +1,122 @@
+// 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 <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<JNIFunctionBody::javaobject> JSIFunctionBody
+  );
+
+  /**
+   * 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<JNIAsyncFunctionBody::javaobject> JSIAsyncFunctionBody
+  );
+
+  /**
+   * 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::map<std::string, MethodMetadata> methodsMetadata;
+
+  /**
+   * A constants map.
+   */
+  std::map<std::string, folly::dynamic> constants;
+
+  explicit JavaScriptModuleObject(jni::alias_ref<jhybridobject> jThis)
+    : javaPart_(jni::make_global(jThis)) {}
+};
+} // namespace expo