expo-modules-core 1.11.13 → 1.12.1

package/src/ts-declarations/EventEmitter.ts

@@ -0,0 +1,65 @@
+/**
+ * Base type of the events map, whose keys represent supported event names
+ * and values are the signatures of the listener for that specific event.
+ */
+export type EventsMap = Record<string, (...args: any[]) => void>;
+
+/**
+ * A subscription object that allows to conveniently remove an event listener from the emitter.
+ */
+export type EventSubscription = {
+  /**
+   * Removes an event listener for which the subscription has been created.
+   * After calling this function, the listener will no longer receive any events from the emitter.
+   */
+  remove(): void;
+};
+
+/**
+ * A class that provides a consistent API for emitting and listening to events.
+ * It shares many concepts with other emitter APIs, such as Node's EventEmitter and `fbemitter`.
+ * When the event is emitted, all of the functions attached to that specific event are called *synchronously*.
+ * Any values returned by the called listeners are *ignored* and discarded.
+ * Its implementation is written in C++ and common for all the platforms.
+ */
+export declare class EventEmitter<TEventsMap extends EventsMap = Record<never, never>> {
+  /**
+   * Creates a new event emitter instance.
+   */
+  constructor();
+
+  /**
+   * Adds a listener for the given event name.
+   */
+  addListener<EventName extends keyof TEventsMap>(
+    eventName: EventName,
+    listener: TEventsMap[EventName]
+  ): EventSubscription;
+
+  /**
+   * Removes a listener for the given event name.
+   */
+  removeListener<EventName extends keyof TEventsMap>(
+    eventName: EventName,
+    listener: TEventsMap[EventName]
+  ): void;
+
+  /**
+   * Removes all listeners for the given event name.
+   */
+  removeAllListeners(eventName: keyof TEventsMap): void;
+
+  /**
+   * Synchronously calls all of the listeners attached to that specific event.
+   * The event can include any number of arguments that will be passed to the listeners.
+   */
+  emit<EventName extends keyof TEventsMap>(
+    eventName: EventName,
+    ...args: Parameters<TEventsMap[EventName]>
+  ): void;
+
+  /**
+   * Returns a number of listeners added to the given event.
+   */
+  listenerCount<EventName extends keyof TEventsMap>(eventName: EventName): number;
+}

package/src/ts-declarations/ExpoModules.d.ts

@@ -2,9 +2,4 @@ import { CodedError } from '../errors/CodedError';
 
 declare let global: {
   ExpoModulesCore_CodedError: typeof CodedError;
-  ExpoModules:
-    | undefined
-    | {
-        [key: string]: any;
-      };
 };

package/src/ts-declarations/NativeModule.ts

@@ -0,0 +1,18 @@
+import type { EventEmitter, EventsMap } from './EventEmitter';
+
+/**
+ * A class for all native modules. Extends the {@link EventEmitter} class.
+ */
+export declare class NativeModule<
+  TEventsMap extends EventsMap = Record<never, never>,
+> extends EventEmitter<TEventsMap> {
+  /**
+   * A prototype of the native component exported by the module.
+   * @deprecated It will be removed in favor of another API that supports multiple components per module.
+   * @private
+   */
+  ViewPrototype?: object;
+
+  // Ideally if we don't have it, but not all modules have concrete types in `requireNativeModule`.
+  [key: string]: any;
+}

package/src/ts-declarations/SharedObject.ts

@@ -0,0 +1,16 @@
+import type { EventEmitter, EventsMap } from './EventEmitter';
+
+/**
+ * Base class for all shared objects that extends the EventEmitter class.
+ * The implementation is written in C++, installed through JSI and common for mobile platforms.
+ */
+export declare class SharedObject<
+  TEventsMap extends EventsMap = Record<never, never>,
+> extends EventEmitter<TEventsMap> {
+  /**
+   * A function that detaches the JS and native objects to let the native object deallocate
+   * before the JS object gets deallocated by the JS garbagge collector. Any subsequent calls to native
+   * functions of the object will throw an error as it is no longer associated with its native counterpart.
+   */
+  release(): void;
+}

package/src/ts-declarations/global.ts

@@ -0,0 +1,60 @@
+import type { EventEmitter } from './EventEmitter';
+import type { NativeModule } from './NativeModule';
+import type { SharedObject } from './SharedObject';
+
+export interface ExpoGlobal {
+  /**
+   * Host object that is used to access native Expo modules.
+   */
+  modules: Record<string, any>;
+
+  // Natively defined JS classes
+
+  /**
+   * @see EventEmitter
+   */
+  EventEmitter: typeof EventEmitter;
+
+  /**
+   * @see SharedObject
+   */
+  SharedObject: typeof SharedObject;
+
+  /**
+   * @see NativeModule
+   */
+  NativeModule: typeof NativeModule;
+
+  // Utils
+
+  /**
+   * Generates a random UUID v4 string.
+   */
+  uuidv4(): string;
+
+  /**
+   * Generates a UUID v5 string representation of the value in the specified namespace.
+   */
+  uuidv5(name: string, namespace: string): string;
+
+  /**
+   * Returns a static view config of the native view with the given name
+   * or `null` if the view has not been registered.
+   */
+  getViewConfig(viewName: string): ViewConfig | null;
+}
+
+type ViewConfig = {
+  validAttributes: Record<string, any>;
+  directEventTypes: Record<string, { registrationName: string }>;
+};
+
+/* eslint-disable no-var */
+
+declare global {
+  /**
+   * Global object containing all the native bindings installed by Expo.
+   * This object is not available in projects without the `expo` package installed.
+   */
+  var expo: ExpoGlobal;
+}

package/src/web/CoreModule.ts

@@ -0,0 +1,83 @@
+import type {
+  EventEmitter as EventEmitterType,
+  EventSubscription,
+  EventsMap,
+} from '../ts-declarations/EventEmitter';
+import type { NativeModule as NativeModuleType } from '../ts-declarations/NativeModule';
+import type { SharedObject as SharedObjectType } from '../ts-declarations/SharedObject';
+import uuid from '../uuid';
+
+class EventEmitter<TEventsMap extends EventsMap> implements EventEmitterType {
+  private listeners?: Map<keyof TEventsMap, Set<Function>>;
+
+  addListener<EventName extends keyof TEventsMap>(
+    eventName: EventName,
+    listener: TEventsMap[EventName]
+  ): EventSubscription {
+    if (!this.listeners) {
+      this.listeners = new Map();
+    }
+    if (!this.listeners?.has(eventName)) {
+      this.listeners?.set(eventName, new Set());
+    }
+    this.listeners?.get(eventName)?.add(listener);
+
+    return {
+      remove: () => {
+        this.removeListener(eventName, listener);
+      },
+    };
+  }
+
+  removeListener<EventName extends keyof TEventsMap>(
+    eventName: EventName,
+    listener: TEventsMap[EventName]
+  ): void {
+    this.listeners?.get(eventName)?.delete(listener);
+  }
+
+  removeAllListeners<EventName extends keyof TEventsMap>(eventName: EventName): void {
+    this.listeners?.get(eventName)?.clear();
+  }
+
+  emit<EventName extends keyof TEventsMap>(
+    eventName: EventName,
+    ...args: Parameters<TEventsMap[EventName]>
+  ): void {
+    this.listeners?.get(eventName)?.forEach((listener) => listener(...args));
+  }
+
+  listenerCount<EventName extends keyof TEventsMap>(eventName: EventName): number {
+    return this.listeners?.get(eventName)?.size ?? 0;
+  }
+}
+
+export class NativeModule<TEventsMap extends Record<never, never>>
+  extends EventEmitter<TEventsMap>
+  implements NativeModuleType
+{
+  [key: string]: any;
+  ViewPrototype?: object | undefined;
+  __expo_module_name__?: string;
+}
+
+class SharedObject<TEventsMap extends Record<never, never>>
+  extends EventEmitter<TEventsMap>
+  implements SharedObjectType
+{
+  release(): void {
+    throw new Error('Method not implemented.');
+  }
+}
+
+globalThis.expo = {
+  EventEmitter,
+  NativeModule,
+  SharedObject,
+  modules: {},
+  uuidv4: uuid.v4,
+  uuidv5: uuid.v5,
+  getViewConfig: () => {
+    throw new Error('Method not implemented.');
+  },
+};

package/src/web/index.web.ts

@@ -0,0 +1 @@
+import './CoreModule';

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

@@ -1,196 +0,0 @@
-// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
-
-#include "JSIInteropModuleRegistry.h"
-#include "ExpoModulesHostObject.h"
-#include "JavaReferencesCache.h"
-#include "JSReferencesCache.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),
-                   makeNativeMethod("wasDeallocated", JSIInteropModuleRegistry::jniWasDeallocated),
-                 });
-}
-
-JSIInteropModuleRegistry::JSIInteropModuleRegistry(jni::alias_ref<jhybridobject> jThis)
-  : javaPart_(jni::make_global(jThis)) {}
-
-void JSIInteropModuleRegistry::installJSI(
-  jlong jsRuntimePointer,
-  jni::alias_ref<JNIDeallocator::javaobject> jniDeallocator,
-  jni::alias_ref<react::CallInvokerHolder::javaobject> jsInvokerHolder
-) {
-  this->jniDeallocator = jni::make_global(jniDeallocator);
-
-  auto runtime = reinterpret_cast<jsi::Runtime *>(jsRuntimePointer);
-
-  jsRegistry = std::make_unique<JSReferencesCache>(*runtime);
-
-  runtimeHolder = std::make_shared<JavaScriptRuntime>(
-    this,
-    runtime,
-    jsInvokerHolder->cthis()->getCallInvoker()
-  );
-
-  runtimeHolder->installMainObject();
-
-  auto expoModules = std::make_shared<ExpoModulesHostObject>(this);
-  auto expoModulesObject = jsi::Object::createFromHostObject(*runtime, expoModules);
-
-  // Define the `global.expo.modules` object.
-  runtimeHolder
-    ->getMainObject()
-    ->setProperty(
-      *runtime,
-      "modules",
-      expoModulesObject
-    );
-
-  // Also define `global.ExpoModules` for backwards compatibility (used before SDK47, can be removed in SDK48).
-  runtime
-    ->global()
-    .setProperty(
-      *runtime,
-      "ExpoModules",
-      expoModulesObject
-    );
-}
-
-void JSIInteropModuleRegistry::installJSIForTests(
-  jni::alias_ref<JNIDeallocator::javaobject> jniDeallocator
-) {
-#if !UNIT_TEST
-  throw std::logic_error("The function is only available when UNIT_TEST is defined.");
-#else
-  this->jniDeallocator = jni::make_global(jniDeallocator);
-
-  runtimeHolder = std::make_shared<JavaScriptRuntime>(this);
-  jsi::Runtime &jsiRuntime = runtimeHolder->get();
-
-  jsRegistry = std::make_unique<JSReferencesCache>(jsiRuntime);
-
-  runtimeHolder->installMainObject();
-
-  auto expoModules = std::make_shared<ExpoModulesHostObject>(this);
-  auto expoModulesObject = jsi::Object::createFromHostObject(jsiRuntime, expoModules);
-
-  runtimeHolder
-    ->getMainObject()
-    ->setProperty(
-      jsiRuntime,
-      "modules",
-      std::move(expoModulesObject)
-    );
-#endif // !UNIT_TEST
-}
-
-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<JavaScriptModuleObject::javaobject>
-JSIInteropModuleRegistry::callGetCoreModuleObject() const {
-  const static auto method = expo::JSIInteropModuleRegistry::javaClassLocal()
-    ->getMethod<jni::local_ref<JavaScriptModuleObject::javaobject>()>(
-      "getCoreModuleObject"
-    );
-
-  return method(javaPart_);
-}
-
-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_);
-}
-
-bool JSIInteropModuleRegistry::callHasModule(const std::string &moduleName) const {
-  const static auto method = expo::JSIInteropModuleRegistry::javaClassLocal()
-    ->getMethod<jboolean(std::string)>(
-      "hasModule"
-    );
-  return (bool) method(javaPart_, moduleName);
-}
-
-jni::local_ref<JavaScriptModuleObject::javaobject>
-JSIInteropModuleRegistry::getModule(const std::string &moduleName) const {
-  return callGetJavaScriptModuleObjectMethod(moduleName);
-}
-
-jni::local_ref<JavaScriptModuleObject::javaobject> JSIInteropModuleRegistry::getCoreModule() const {
-  return callGetCoreModuleObject();
-}
-
-bool JSIInteropModuleRegistry::hasModule(const std::string &moduleName) const {
-  return callHasModule(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();
-}
-
-void JSIInteropModuleRegistry::registerSharedObject(
-  jni::local_ref<jobject> native,
-  jni::local_ref<JavaScriptObject::javaobject> js
-) {
-  const static auto method = expo::JSIInteropModuleRegistry::javaClassLocal()
-    ->getMethod<void(jni::local_ref<jobject>, jni::local_ref<JavaScriptObject::javaobject>)>(
-      "registerSharedObject"
-    );
-  method(javaPart_, std::move(native), std::move(js));
-}
-
-void JSIInteropModuleRegistry::jniWasDeallocated() {
-  wasDeallocated = true;
-}
-} // namespace expo

package/android/src/main/java/expo/modules/adapters/react/ArgumentsHelper.java

@@ -1,48 +0,0 @@
-package expo.modules.adapters.react;
-
-import com.facebook.react.bridge.Dynamic;
-
-import expo.modules.core.arguments.MapArguments;
-import expo.modules.core.arguments.ReadableArguments;
-
-public class ArgumentsHelper {
-  public static Object getNativeArgumentForExpectedClass(Dynamic argument, Class<?> expectedArgumentClass) {
-    switch (argument.getType()) {
-      case String:
-        return argument.asString();
-      case Map:
-        if (expectedArgumentClass.isAssignableFrom(ReadableArguments.class)) {
-          return new MapArguments(argument.asMap().toHashMap());
-        }
-        return argument.asMap().toHashMap();
-      case Array:
-        return argument.asArray().toArrayList();
-      case Number:
-        // Argument of type .Number is remembered as Double by default.
-        Double doubleArgument = argument.asDouble();
-        // We have to provide ExportedModule with proper Number value
-        if (expectedArgumentClass == byte.class || expectedArgumentClass == Byte.class) {
-          return doubleArgument.byteValue();
-        } else if (expectedArgumentClass == short.class || expectedArgumentClass == Short.class) {
-          return doubleArgument.shortValue();
-        } else if (expectedArgumentClass == int.class || expectedArgumentClass == Integer.class) {
-          return doubleArgument.intValue();
-        } else if (expectedArgumentClass == float.class || expectedArgumentClass == Float.class) {
-          return doubleArgument.floatValue();
-        } else if (expectedArgumentClass == long.class || expectedArgumentClass == Long.class) {
-          return doubleArgument.longValue();
-        } else {
-          return doubleArgument;
-        }
-      case Boolean:
-        return argument.asBoolean();
-      case Null:
-        return null;
-      default:
-        // JS argument is not null, however we can't recognize the type.
-        throw new RuntimeException(
-            "Don't know how to convert React Native argument of type " + argument.getType() + " to native."
-        );
-    }
-  }
-}

package/android/src/main/java/expo/modules/adapters/react/PromiseWrapper.java

@@ -1,38 +0,0 @@
-package expo.modules.adapters.react;
-
-import android.os.Bundle;
-
-import com.facebook.react.bridge.Arguments;
-
-import expo.modules.core.Promise;
-
-import java.util.List;
-
-import javax.annotation.Nullable;
-
-/**
- * Decorator for {@link com.facebook.react.bridge.Promise},
- * so we don't have to implement these inline in {@link NativeModulesProxy}.
- */
-/* package */ class PromiseWrapper implements Promise {
-  private com.facebook.react.bridge.Promise mPromise;
-
-  /* package */ PromiseWrapper(com.facebook.react.bridge.Promise promise) {
-    super();
-    mPromise = promise;
-  }
-
-  public void resolve(@Nullable Object value) {
-    if (value instanceof Bundle) {
-      mPromise.resolve(Arguments.fromBundle((Bundle) value));
-    } else if (value instanceof List) {
-      mPromise.resolve(Arguments.fromList((List) value));
-    } else {
-      mPromise.resolve(value);
-    }
-  }
-
-  public void reject(String code, String message, Throwable e) {
-    mPromise.reject(code, message, e);
-  }
-}

package/android/src/main/java/expo/modules/adapters/react/services/CookieManagerModule.java

@@ -1,53 +0,0 @@
-package expo.modules.adapters.react.services;
-
-import com.facebook.react.bridge.NativeModule;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.modules.network.ForwardingCookieHandler;
-
-import java.net.CookieHandler;
-import java.util.Collections;
-import java.util.List;
-
-import expo.modules.core.interfaces.InternalModule;
-
-public class CookieManagerModule extends ForwardingCookieHandler implements InternalModule, NativeModule {
-  private static final String TAG = "CookieManagerModule";
-
-  public CookieManagerModule(ReactContext context) {
-    super(context);
-  }
-
-  @Override
-  public String getName() {
-    return null;
-  }
-
-  @Override
-  public void initialize() {
-    // do nothing
-  }
-
-  @Override
-  public List<Class> getExportedInterfaces() {
-    return Collections.singletonList((Class) CookieHandler.class);
-  }
-
-  @Override
-  public boolean canOverrideExistingModule() {
-    return false;
-  }
-
-  // `invalidate` replaces `onCatalystInstanceDestroy` in recent RN versions. We can't use
-  // @Override here since older versions won't have this method. If one of these methods is
-  // needed make sure to add the code to both as only one of the methods will be called depending
-  // on the RN version.
-  // See https://github.com/facebook/react-native/commit/18c8417290823e67e211bde241ae9dde27b72f17
-  public void invalidate() {
-    // do nothing
-  }
-
-  @Override
-  public void onCatalystInstanceDestroy() {
-    // do nothing
-  }
-}

package/android/src/main/java/expo/modules/core/ArgumentsHelper.java

@@ -1,44 +0,0 @@
-package expo.modules.core;
-
-public class ArgumentsHelper {
-  /* package */ static Object validatedArgumentForClass(Object argument, Class<?> expectedArgumentClass) {
-    if (Object.class.isAssignableFrom(expectedArgumentClass)) {
-      // Expected argument class is an Object descendant
-      if (argument != null) {
-        // Actual argument is not null, so we can check whether
-        // its class matches expectation.
-        Class<?> actualArgumentClass = argument.getClass();
-
-        if (!expectedArgumentClass.isAssignableFrom(actualArgumentClass)) {
-          // Expected argument class is not assignable from actual argument class
-          // i. e. eg. Map was provided for a String argument.
-          throw new IllegalArgumentException(
-                  "Argument of an incompatible class: " + actualArgumentClass
-                          + " cannot be passed as an argument to parameter expecting " + expectedArgumentClass + ".");
-        }
-      }
-    } else {
-      // Argument is of primitive type, like boolean or int.
-      if (argument == null) {
-        throw new IllegalArgumentException(
-                "Argument null cannot be passed to an argument to parameter expecting " + expectedArgumentClass + ".");
-      }
-
-      Class<?> actualArgumentClass = argument.getClass();
-      if (expectedArgumentClass != actualArgumentClass) {
-        if (!Number.class.isAssignableFrom(actualArgumentClass) && !Boolean.class.isAssignableFrom(actualArgumentClass)) {
-          throw new IllegalArgumentException("Argument of an incompatible class: "
-                  + actualArgumentClass + " cannot be passed as an argument to parameter expecting " + expectedArgumentClass + ".");
-        }
-
-        // Otherwise the expected argument is of type int or long or booealn and actual argument class is a descendant of Number or Boolean.
-        // We believe that platform adapter has coerced the value correctly and when expected argument
-        // is int, actual argument is Integer; when expected is float, actual is Float, etc.
-        // If it's not, Java will throw a developer-readable exception.
-      }
-    }
-
-    // All checks passed
-    return argument;
-  }
-}