expo-modules-core 0.9.0 → 0.10.0

package/ios/JSI/EXJavaScriptTypedArray.h

@@ -0,0 +1,30 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+#import <ExpoModulesCore/EXJavaScriptObject.h>
+#import <ExpoModulesCore/EXJavaScriptRuntime.h>
+
+// We need to redefine the C++ enum (see TypedArray.h) in an Objective-C way to expose it to Swift.
+// Please keep them in-sync!
+typedef NS_ENUM(NSInteger, EXTypedArrayKind) {
+  Int8Array = 1,
+  Int16Array = 2,
+  Int32Array = 3,
+  Uint8Array = 4,
+  Uint8ClampedArray = 5,
+  Uint16Array = 6,
+  Uint32Array = 7,
+  Float32Array = 8,
+  Float64Array = 9,
+  BigInt64Array = 10,
+  BigUint64Array = 11,
+} NS_SWIFT_NAME(TypedArrayKind);
+
+NS_SWIFT_NAME(JavaScriptTypedArray)
+@interface EXJavaScriptTypedArray : EXJavaScriptObject
+
+@property (nonatomic) EXTypedArrayKind kind;
+
+- (nonnull void *)getUnsafeMutableRawPointer;
+
+@end

package/ios/JSI/EXJavaScriptTypedArray.mm

@@ -0,0 +1,29 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXJavaScriptTypedArray.h>
+#import <ExpoModulesCore/TypedArray.h>
+
+@implementation EXJavaScriptTypedArray {
+  __weak EXJavaScriptRuntime *_runtime;
+
+  std::shared_ptr<expo::TypedArray> _typedArrayPtr;
+}
+
+- (nonnull instancetype)initWith:(std::shared_ptr<jsi::Object>)jsObjectPtr
+                         runtime:(EXJavaScriptRuntime *)runtime
+{
+  if (self = [super initWith:jsObjectPtr runtime:runtime]) {
+    jsi::Runtime *rt = [runtime get];
+    _runtime = runtime;
+    _typedArrayPtr = std::make_shared<expo::TypedArray>(*rt, *jsObjectPtr.get());
+    _kind = (EXTypedArrayKind)_typedArrayPtr->getKind(*rt);
+  }
+  return self;
+}
+
+- (nonnull void *)getUnsafeMutableRawPointer
+{
+  return _typedArrayPtr->getRawPointer(*[_runtime get]);
+}
+
+@end

package/ios/JSI/EXJavaScriptValue.h

@@ -9,6 +9,7 @@ namespace jsi = facebook::jsi;
 #endif // __cplusplus
 
 @class EXJavaScriptRuntime;
+@class EXJavaScriptTypedArray;
 
 /**
  Represents any JavaScript value. Its purpose is to exposes `facebook::jsi::Value` API back to Swift.
@@ -36,8 +37,7 @@ NS_SWIFT_NAME(JavaScriptValue)
 - (BOOL)isSymbol;
 - (BOOL)isObject;
 - (BOOL)isFunction;
-
-+ (nonnull NSString *)kindOf:(nonnull EXJavaScriptValue *)value;
+- (BOOL)isTypedArray;
 
 #pragma mark - Type casting
 
@@ -49,6 +49,7 @@ NS_SWIFT_NAME(JavaScriptValue)
 - (nonnull NSArray<EXJavaScriptValue *> *)getArray;
 - (nonnull NSDictionary<NSString *, id> *)getDictionary;
 - (nonnull EXJavaScriptObject *)getObject;
+- (nullable EXJavaScriptTypedArray *)getTypedArray;
 
 #pragma mark - Helpers
 

package/ios/JSI/EXJavaScriptValue.mm

@@ -3,6 +3,8 @@
 #import <ExpoModulesCore/EXJSIConversions.h>
 #import <ExpoModulesCore/EXJavaScriptValue.h>
 #import <ExpoModulesCore/EXJavaScriptRuntime.h>
+#import <ExpoModulesCore/EXJavaScriptTypedArray.h>
+#import <ExpoModulesCore/TypedArray.h>
 
 @implementation EXJavaScriptValue {
   __weak EXJavaScriptRuntime *_runtime;
@@ -70,28 +72,13 @@
   return false;
 }
 
-+ (nonnull NSString *)kindOf:(nonnull EXJavaScriptValue *)value
+- (BOOL)isTypedArray
 {
-  if ([value isUndefined]) {
-    return @"undefined";
-  }
-  if ([value isNull]) {
-    return @"null";
-  }
-  if ([value isBool]) {
-    return @"boolean";
-  }
-  if ([value isNumber]) {
-    return @"number";
-  }
-  if ([value isString]) {
-    return @"string";
-  }
-  if ([value isFunction]) {
-    return @"function";
+  if (_value->isObject()) {
+    jsi::Runtime *runtime = [_runtime get];
+    return expo::isTypedArray(*runtime, _value->getObject(*runtime));
   }
-  assert([value isObject] && "Expecting object.");
-  return @"object";
+  return false;
 }
 
 #pragma mark - Type casting
@@ -155,6 +142,16 @@
   return [[EXJavaScriptObject alloc] initWith:objectPtr runtime:_runtime];
 }
 
+- (nullable EXJavaScriptTypedArray *)getTypedArray
+{
+  if (![self isTypedArray]) {
+    return nil;
+  }
+  jsi::Runtime *runtime = [_runtime get];
+  std::shared_ptr<jsi::Object> objectPtr = std::make_shared<jsi::Object>(_value->asObject(*runtime));
+  return [[EXJavaScriptTypedArray alloc] initWith:objectPtr runtime:_runtime];
+}
+
 #pragma mark - Helpers
 
 - (nonnull NSString *)toString

package/ios/JSI/EXJavaScriptWeakObject.h

@@ -0,0 +1,23 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+#import <ExpoModulesCore/EXJavaScriptValue.h>
+#import <ExpoModulesCore/EXJavaScriptRuntime.h>
+
+#ifdef __cplusplus
+#import <jsi/jsi.h>
+
+namespace jsi = facebook::jsi;
+#endif // __cplusplus
+
+NS_SWIFT_NAME(JavaScriptWeakObject)
+@interface EXJavaScriptWeakObject : NSObject
+
+#ifdef __cplusplus
+- (nonnull instancetype)initWith:(std::shared_ptr<jsi::Object>)jsObject
+                         runtime:(nonnull EXJavaScriptRuntime *)runtime;
+#endif // __cplusplus
+
+- (nullable EXJavaScriptObject *)lock;
+
+@end

package/ios/JSI/EXJavaScriptWeakObject.mm

@@ -0,0 +1,53 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXJSIUtils.h>
+#import <ExpoModulesCore/EXJavaScriptWeakObject.h>
+
+@implementation EXJavaScriptWeakObject {
+  /**
+   Pointer to the `EXJavaScriptRuntime` wrapper.
+
+   \note It must be weak because only then the original runtime can be safely deallocated
+   when the JS engine wants to without unsetting it on each created object.
+   */
+  __weak EXJavaScriptRuntime *_runtime;
+
+  /**
+   Shared pointer to the `WeakRef` JS object.
+   */
+  std::shared_ptr<jsi::Object> _jsObject;
+}
+
+- (nonnull instancetype)initWith:(std::shared_ptr<jsi::Object>)jsObject
+                         runtime:(nonnull EXJavaScriptRuntime *)runtime
+{
+  if (self = [super init]) {
+    _runtime = runtime;
+
+    // Check whether the runtime supports `WeakRef` objects. If it does not,
+    // we consciously hold a strong reference to the object and cause memory leaks.
+    // This is the case on hermes and JSC prior to iOS 14.5.
+    // TODO: (@tsapeta) Use `jsi::WeakObject` on hermes
+    if (expo::isWeakRefSupported(*[runtime get])) {
+      _jsObject = expo::createWeakRef(*[runtime get], jsObject);
+    } else {
+      _jsObject = jsObject;
+    }
+  }
+  return self;
+}
+
+- (nullable EXJavaScriptObject *)lock
+{
+  jsi::Runtime *runtime = [_runtime get];
+  std::shared_ptr<jsi::Object> objectPtr = expo::isWeakRefSupported(*runtime)
+    ? expo::derefWeakRef(*runtime, _jsObject)
+    : _jsObject;
+
+  if (!objectPtr) {
+    return nil;
+  }
+  return [[EXJavaScriptObject alloc] initWith:objectPtr runtime:_runtime];
+}
+
+@end

package/ios/JSI/EXObjectDeallocator.h

@@ -0,0 +1,27 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#ifdef __cplusplus
+
+#import <jsi/jsi.h>
+
+namespace jsi = facebook::jsi;
+
+namespace expo {
+
+typedef void (^ObjectDeallocatorBlock)();
+
+class JSI_EXPORT ObjectDeallocator : public jsi::HostObject {
+public:
+  ObjectDeallocator(const ObjectDeallocatorBlock deallocator) : deallocator(deallocator) {};
+
+  virtual ~ObjectDeallocator() {
+    deallocator();
+  }
+
+  const ObjectDeallocatorBlock deallocator;
+
+}; // class ObjectDeallocator
+
+} // namespace expo
+
+#endif

package/ios/JSI/ExpoModulesHostObject.h

@@ -7,13 +7,13 @@
 
 namespace jsi = facebook::jsi;
 
-@class SwiftInteropBridge;
+@class EXAppContext;
 
 namespace expo {
 
 class JSI_EXPORT ExpoModulesHostObject : public jsi::HostObject {
 public:
-  ExpoModulesHostObject(SwiftInteropBridge *interopBridge);
+  ExpoModulesHostObject(EXAppContext *appContext);
 
   virtual ~ExpoModulesHostObject();
 
@@ -24,7 +24,7 @@ public:
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
 private:
-  SwiftInteropBridge *swiftInterop;
+  EXAppContext *appContext;
 
 }; // class ExpoModulesHostObject
 

package/ios/JSI/ExpoModulesHostObject.mm

@@ -6,15 +6,15 @@
 
 namespace expo {
 
-ExpoModulesHostObject::ExpoModulesHostObject(SwiftInteropBridge *swiftInterop) : swiftInterop(swiftInterop) {}
+ExpoModulesHostObject::ExpoModulesHostObject(EXAppContext *appContext) : appContext(appContext) {}
 
 ExpoModulesHostObject::~ExpoModulesHostObject() {
-  [swiftInterop setRuntime:nil];
+  [appContext setRuntime:nil];
 }
 
 jsi::Value ExpoModulesHostObject::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
   NSString *moduleName = [NSString stringWithUTF8String:name.utf8(runtime).c_str()];
-  EXJavaScriptObject *nativeObject = [swiftInterop getNativeModuleObject:moduleName];
+  EXJavaScriptObject *nativeObject = [appContext getNativeModuleObject:moduleName];
 
   return nativeObject ? jsi::Value(runtime, *[nativeObject get]) : jsi::Value::undefined();
 }
@@ -27,7 +27,7 @@ void ExpoModulesHostObject::set(jsi::Runtime &runtime, const jsi::PropNameID &na
 }
 
 std::vector<jsi::PropNameID> ExpoModulesHostObject::getPropertyNames(jsi::Runtime &runtime) {
-  NSArray<NSString *> *moduleNames = [swiftInterop getModuleNames];
+  NSArray<NSString *> *moduleNames = [appContext getModuleNames];
   std::vector<jsi::PropNameID> propertyNames;
 
   propertyNames.reserve([moduleNames count]);

package/ios/JSI/JavaScriptRuntime.swift

@@ -1,6 +1,11 @@
 // Copyright 2022-present 650 Industries. All rights reserved.
 
 public extension JavaScriptRuntime {
+  /**
+   A type of the closure that you pass to the `createSyncFunction` function.
+   */
+  typealias SyncFunctionClosure = (_ this: JavaScriptValue, _ arguments: [JavaScriptValue]) throws -> Any
+
   /**
    Evaluates JavaScript code represented as a string.
 
@@ -11,11 +16,12 @@ public extension JavaScriptRuntime {
    - Throws: `JavaScriptEvalException` when evaluated code has invalid syntax or throws an error.
    - Note: It wraps the original `evaluateScript` to better handle and rethrow exceptions.
    */
+  @discardableResult
   func eval(_ source: String) throws -> JavaScriptValue {
     do {
       var result: JavaScriptValue?
       try EXUtilities.catchException {
-        result = self.evaluateScript(source)
+        result = self.__evaluateScript(source)
       }
       // There is no risk to force unwrapping as long as the `evaluateScript` returns nonnull value.
       return result!
@@ -23,6 +29,37 @@ public extension JavaScriptRuntime {
       throw JavaScriptEvalException(error as NSError)
     }
   }
+
+  /**
+   Evaluates the JavaScript code made by joining an array of strings with a newline separator.
+   See the other ``eval(_:)`` for more details.
+   */
+  @discardableResult
+  func eval(_ source: [String]) throws -> JavaScriptValue {
+    try eval(source.joined(separator: "\n"))
+  }
+
+  /**
+   Creates a synchronous host function that runs the given closure when it's called.
+   The value returned by the closure is synchronously returned to JS.
+   - Returns: A JavaScript function represented as a `JavaScriptObject`.
+   - Note: It refines the ObjC implementation from `EXJavaScriptRuntime` to properly catch Swift errors and rethrow them as ObjC `NSError`.
+   */
+  func createSyncFunction(_ name: String, argsCount: Int = 0, closure: @escaping SyncFunctionClosure) -> JavaScriptObject {
+    return __createSyncFunction(name, argsCount: argsCount) { this, args, errorPointer in
+      do {
+        return try runWithErrorPointer(errorPointer) {
+          return try closure(this, args)
+        }
+      } catch {
+        // Nicely log all errors to the console.
+        log.error(error)
+
+        // Can return anything as the error will be caught through the error pointer already.
+        return nil
+      }
+    }
+  }
 }
 
 internal final class JavaScriptEvalException: GenericException<NSError> {

package/ios/JSI/JavaScriptValue.swift

@@ -85,6 +85,13 @@ public extension JavaScriptValue {
     }
     throw JavaScriptValueConversionException((kind: kind, target: "Object"))
   }
+
+  func asTypedArray() throws -> JavaScriptTypedArray {
+    if let typedArray = getTypedArray() {
+      return typedArray
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "TypedArray"))
+  }
 }
 
 internal final class JavaScriptValueConversionException: GenericException<(kind: JavaScriptValueKind, target: String)> {

package/ios/JSI/TypedArray.cpp

@@ -0,0 +1,67 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#include <unordered_map>
+#include "TypedArray.h"
+
+namespace expo {
+
+std::unordered_map<std::string, TypedArrayKind> nameToKindMap = {
+    {"Int8Array", TypedArrayKind::Int8Array},
+    {"Int16Array", TypedArrayKind::Int16Array},
+    {"Int32Array", TypedArrayKind::Int32Array},
+    {"Uint8Array", TypedArrayKind::Uint8Array},
+    {"Uint8ClampedArray", TypedArrayKind::Uint8ClampedArray},
+    {"Uint16Array", TypedArrayKind::Uint16Array},
+    {"Uint32Array", TypedArrayKind::Uint32Array},
+    {"Float32Array", TypedArrayKind::Float32Array},
+    {"Float64Array", TypedArrayKind::Float64Array},
+    {"BigInt64Array", TypedArrayKind::BigInt64Array},
+    {"BigUint64Array", TypedArrayKind::BigUint64Array},
+};
+
+TypedArrayKind getTypedArrayKindForName(const std::string &name) {
+  return nameToKindMap.at(name);
+}
+
+TypedArray::TypedArray(jsi::Runtime &runtime, const jsi::Object &obj)
+    : jsi::Object(jsi::Value(runtime, obj).asObject(runtime)) {}
+
+TypedArrayKind TypedArray::getKind(jsi::Runtime &runtime) const {
+  auto constructorName = this->getPropertyAsObject(runtime, "constructor")
+                             .getProperty(runtime, "name")
+                             .asString(runtime)
+                             .utf8(runtime);
+  return getTypedArrayKindForName(constructorName);
+};
+
+size_t TypedArray::byteOffset(jsi::Runtime &runtime) const {
+  return getProperty(runtime, "byteOffset").asNumber();
+}
+
+jsi::ArrayBuffer TypedArray::getBuffer(jsi::Runtime &runtime) const {
+  auto buffer = getProperty(runtime, "buffer");
+  if (buffer.isObject() && buffer.asObject(runtime).isArrayBuffer(runtime)) {
+    return buffer.asObject(runtime).getArrayBuffer(runtime);
+  } else {
+    throw std::runtime_error("no ArrayBuffer attached");
+  }
+}
+
+void* TypedArray::getRawPointer(jsi::Runtime &runtime) {
+  return reinterpret_cast<void *>(getBuffer(runtime).data(runtime) + byteOffset(runtime));
+}
+
+bool isTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj) {
+  jsi::Object ArrayBuffer = runtime
+    .global()
+    .getPropertyAsObject(runtime, "ArrayBuffer");
+
+  jsi::Value isViewResult = ArrayBuffer
+    .getPropertyAsFunction(runtime, "isView")
+    .callWithThis(runtime, ArrayBuffer, {jsi::Value(runtime, jsObj)});
+
+  assert(isViewResult.isBool());
+  return isViewResult.getBool();
+}
+
+} // namespace expo

package/ios/JSI/TypedArray.h

@@ -0,0 +1,46 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#ifdef __cplusplus
+
+#include <jsi/jsi.h>
+
+namespace jsi = facebook::jsi;
+
+namespace expo {
+
+// Please keep it in-sync with the `EXTypedArrayKind` in Objective-C.
+// We need to maintain two implementations to expose this enum to Swift.
+enum class TypedArrayKind {
+  Int8Array = 1,
+  Int16Array = 2,
+  Int32Array = 3,
+  Uint8Array = 4,
+  Uint8ClampedArray = 5,
+  Uint16Array = 6,
+  Uint32Array = 7,
+  Float32Array = 8,
+  Float64Array = 9,
+  BigInt64Array = 10,
+  BigUint64Array = 11,
+};
+
+class TypedArray : public jsi::Object {
+ public:
+  TypedArray(jsi::Runtime &, const jsi::Object &);
+  TypedArray(TypedArray &&) = default;
+  TypedArray &operator=(TypedArray &&) = default;
+
+  TypedArrayKind getKind(jsi::Runtime &runtime) const;
+
+  size_t byteOffset(jsi::Runtime &runtime) const;
+
+  jsi::ArrayBuffer getBuffer(jsi::Runtime &runtime) const;
+
+  void* getRawPointer(jsi::Runtime &runtime);
+};
+
+bool isTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj);
+
+} // namespace expo
+
+#endif // __cplusplus

package/ios/ModuleRegistryAdapter/EXModuleRegistryAdapter.m

@@ -7,13 +7,11 @@
 #import <ExpoModulesCore/EXViewManagerAdapterClassesRegistry.h>
 #import <ExpoModulesCore/EXModuleRegistryHolderReactModule.h>
 #import <ExpoModulesCore/EXReactNativeEventEmitter.h>
-#import <ExpoModulesCore/Swift.h>
 
 @interface EXModuleRegistryAdapter ()
 
 @property (nonatomic, strong) EXModuleRegistryProvider *moduleRegistryProvider;
 @property (nonatomic, strong) EXViewManagerAdapterClassesRegistry *viewManagersClassesRegistry;
-@property (nonatomic, strong, nullable) ModulesProvider *swiftModulesProvider;
 
 @end
 
@@ -75,13 +73,4 @@
   return extraModules;
 }
 
-- (nullable SwiftInteropBridge *)swiftInteropBridgeModulesRegistry:(EXModuleRegistry *)moduleRegistry
-{
-  if (_swiftModulesProvider) {
-    return [[SwiftInteropBridge alloc] initWithModulesProvider:_swiftModulesProvider legacyModuleRegistry:moduleRegistry];
-  } else {
-    return nil;
-  }
-}
-
 @end

package/ios/NativeModulesProxy/EXNativeModulesProxy.h

@@ -5,26 +5,33 @@
 #import <ExpoModulesCore/EXInternalModule.h>
 #import <ExpoModulesCore/EXModuleRegistry.h>
 
+// A convenience class, which acts as a store for the native modules proxy config
+
+NS_SWIFT_NAME(ModulesProxyConfig)
+@interface EXModulesProxyConfig : NSObject
+
+- (instancetype)initWithConstants:(nonnull NSDictionary *)constants
+                      methodNames:(nonnull NSDictionary *)methodNames
+                     viewManagers:(nonnull NSDictionary *)viewManagerMetadata;
+
+- (void)addEntriesFromConfig:(nonnull const EXModulesProxyConfig *)config;
+- (nonnull NSDictionary<NSString *, id> *)toDictionary;
+
+@end
+
 // RCTBridgeModule capable of receiving method calls from JS and forwarding them
 // to proper exported universal modules. Also, it exports important constants to JS, like
 // properties of exported methods and modules' constants.
 
-// Swift compatibility headers (e.g. `ExpoModulesCore-Swift.h`) are not available in headers,
-// so we use class forward declaration here. Swift header must be imported in the `.m` file.
-@class SwiftInteropBridge;
-@class ModulesProvider;
-
-NS_SWIFT_NAME(NativeModulesProxy)
+NS_SWIFT_NAME(LegacyNativeModulesProxy)
 @interface EXNativeModulesProxy : NSObject <RCTBridgeModule>
 
-@property (nonatomic, strong) SwiftInteropBridge *swiftInteropBridge;
+@property (nonatomic, strong, readonly) EXModulesProxyConfig *nativeModulesConfig;
 
 - (nonnull instancetype)init;
 - (nonnull instancetype)initWithModuleRegistry:(nullable EXModuleRegistry *)moduleRegistry;
+- (nonnull instancetype)initWithCustomModuleRegistry:(nonnull EXModuleRegistry *)moduleRegistry;
 
 - (void)callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNameOrKey arguments:(NSArray *)arguments resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
-- (id)callMethodSync:(NSString *)moduleName methodName:(NSString *)methodName arguments:(NSArray *)arguments;
-
-+ (ModulesProvider *)getExpoModulesProvider;
 
 @end