expo-modules-core 0.6.5 → 0.9.0

package/ios/JSI/EXJavaScriptRuntime.h

@@ -0,0 +1,73 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXJavaScriptValue.h>
+#import <ExpoModulesCore/EXJavaScriptObject.h>
+
+#ifdef __cplusplus
+#import <ReactCommon/CallInvoker.h>
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+#endif // __cplusplus
+
+@class EXJavaScriptValue;
+@class EXJavaScriptObject;
+
+#ifdef __cplusplus
+typedef jsi::Value (^JSHostFunctionBlock)(jsi::Runtime &runtime, std::shared_ptr<react::CallInvoker> callInvoker, NSArray<EXJavaScriptValue *> * _Nonnull arguments);
+#endif // __cplusplus
+
+NS_SWIFT_NAME(JavaScriptRuntime)
+@interface EXJavaScriptRuntime : NSObject
+
+/**
+ Creates a new JavaScript runtime.
+ */
+- (nonnull instancetype)init;
+
+#ifdef __cplusplus
+- (nonnull instancetype)initWithRuntime:(nonnull jsi::Runtime *)runtime
+                            callInvoker:(std::shared_ptr<react::CallInvoker>)callInvoker;
+
+/**
+ Returns the underlying runtime object.
+ */
+- (nonnull jsi::Runtime *)get;
+
+/**
+ Returns the call invoker the runtime was initialized with.
+ */
+- (std::shared_ptr<react::CallInvoker>)callInvoker;
+
+/**
+ Wraps given host object to `EXJavaScriptObject`.
+ */
+- (nonnull EXJavaScriptObject *)createHostObject:(std::shared_ptr<jsi::HostObject>)jsiHostObjectPtr;
+
+- (jsi::Function)createSyncFunction:(nonnull NSString *)name
+                          argsCount:(NSInteger)argsCount
+                              block:(nonnull JSSyncFunctionBlock)block;
+
+- (jsi::Function)createAsyncFunction:(nonnull NSString *)name
+                           argsCount:(NSInteger)argsCount
+                               block:(nonnull JSAsyncFunctionBlock)block;
+#endif // __cplusplus
+
+/**
+ Returns the runtime global object for use in Swift.
+ */
+- (nonnull EXJavaScriptObject *)global;
+
+/**
+ Creates a new object for use in Swift.
+ */
+- (nonnull EXJavaScriptObject *)createObject;
+
+#pragma mark - Script evaluation
+
+/**
+ Evaluates given JavaScript source code.
+ */
+- (nonnull EXJavaScriptValue *)evaluateScript:(nonnull NSString *)scriptSource;
+
+@end

package/ios/JSI/EXJavaScriptRuntime.mm

@@ -0,0 +1,153 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <jsi/jsi.h>
+
+#if __has_include(<reacthermes/HermesExecutorFactory.h>)
+#import <reacthermes/HermesExecutorFactory.h>
+#elif __has_include(<hermes/hermes.h>)
+#import <hermes/hermes.h>
+#else
+#import <jsi/JSCRuntime.h>
+#endif
+
+#import <ExpoModulesCore/EXJavaScriptRuntime.h>
+#import <ExpoModulesCore/ExpoModulesHostObject.h>
+#import <ExpoModulesCore/EXJSIUtils.h>
+#import <ExpoModulesCore/EXJSIConversions.h>
+#import <ExpoModulesCore/Swift.h>
+
+using namespace facebook;
+
+@implementation EXJavaScriptRuntime {
+  std::shared_ptr<jsi::Runtime> _runtime;
+  std::shared_ptr<react::CallInvoker> _jsCallInvoker;
+}
+
+/**
+ Initializes a runtime that is independent from React Native and its runtime initialization.
+ This flow is mostly intended for tests. The JS call invoker is unavailable thus calling async functions is not supported.
+ TODO: Implement the call invoker when it becomes necessary.
+ */
+- (nonnull instancetype)init
+{
+  if (self = [super init]) {
+#if __has_include(<reacthermes/HermesExecutorFactory.h>) || __has_include(<hermes/hermes.h>)
+    _runtime = hermes::makeHermesRuntime();
+#else
+    _runtime = jsc::makeJSCRuntime();
+#endif
+    _jsCallInvoker = nil;
+  }
+  return self;
+}
+
+- (nonnull instancetype)initWithRuntime:(nonnull jsi::Runtime *)runtime
+                            callInvoker:(std::shared_ptr<react::CallInvoker>)callInvoker
+{
+  if (self = [super init]) {
+    // Creating a shared pointer that points to the runtime but doesn't own it, thus doesn't release it.
+    // In this code flow, the runtime should be owned by something else like the RCTBridge.
+    // See explanation for constructor (8): https://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr
+    _runtime = std::shared_ptr<jsi::Runtime>(std::shared_ptr<jsi::Runtime>(), runtime);
+    _jsCallInvoker = callInvoker;
+  }
+  return self;
+}
+
+- (nonnull jsi::Runtime *)get
+{
+  return _runtime.get();
+}
+
+- (std::shared_ptr<react::CallInvoker>)callInvoker
+{
+  return _jsCallInvoker;
+}
+
+- (nonnull EXJavaScriptObject *)createObject
+{
+  auto jsObjectPtr = std::make_shared<jsi::Object>(*_runtime);
+  return [[EXJavaScriptObject alloc] initWith:jsObjectPtr runtime:self];
+}
+
+- (nonnull EXJavaScriptObject *)createHostObject:(std::shared_ptr<jsi::HostObject>)jsiHostObjectPtr
+{
+  auto jsObjectPtr = std::make_shared<jsi::Object>(jsi::Object::createFromHostObject(*_runtime, jsiHostObjectPtr));
+  return [[EXJavaScriptObject alloc] initWith:jsObjectPtr runtime:self];
+}
+
+- (nonnull EXJavaScriptObject *)global
+{
+  auto jsGlobalPtr = std::make_shared<jsi::Object>(_runtime->global());
+  return [[EXJavaScriptObject alloc] initWith:jsGlobalPtr runtime:self];
+}
+
+- (jsi::Function)createSyncFunction:(nonnull NSString *)name
+                          argsCount:(NSInteger)argsCount
+                              block:(nonnull JSSyncFunctionBlock)block
+{
+  return [self createHostFunction:name argsCount:argsCount block:^jsi::Value(jsi::Runtime &runtime, std::shared_ptr<react::CallInvoker> callInvoker, NSArray * _Nonnull arguments) {
+    return expo::convertObjCObjectToJSIValue(runtime, block(arguments));
+  }];
+}
+
+- (jsi::Function)createAsyncFunction:(nonnull NSString *)name
+                           argsCount:(NSInteger)argsCount
+                               block:(nonnull JSAsyncFunctionBlock)block
+{
+  return [self createHostFunction:name argsCount:argsCount block:^jsi::Value(jsi::Runtime &runtime, std::shared_ptr<react::CallInvoker> callInvoker, NSArray *arguments) {
+    if (!callInvoker) {
+      // In mocked environment the call invoker may be null so it's not supported to call async functions.
+      // Testing async functions is a bit more complicated anyway. See `init` description for more.
+      throw jsi::JSError(runtime, "Calling async functions is not supported when the call invoker is unavailable");
+    }
+    // The function that is invoked as a setup of the EXJavaScript `Promise`.
+    auto promiseSetup = [callInvoker, block, arguments](jsi::Runtime &runtime, std::shared_ptr<Promise> promise) {
+      expo::callPromiseSetupWithBlock(runtime, callInvoker, promise, ^(RCTPromiseResolveBlock resolver, RCTPromiseRejectBlock rejecter) {
+        block(arguments, resolver, rejecter);
+      });
+    };
+    return createPromiseAsJSIValue(runtime, promiseSetup);
+  }];
+}
+
+#pragma mark - Script evaluation
+
+- (nonnull EXJavaScriptValue *)evaluateScript:(nonnull NSString *)scriptSource
+{
+  std::shared_ptr<jsi::StringBuffer> scriptBuffer = std::make_shared<jsi::StringBuffer>([scriptSource UTF8String]);
+  std::shared_ptr<jsi::Value> result;
+
+  try {
+    result = std::make_shared<jsi::Value>(_runtime->evaluateJavaScript(scriptBuffer, "<<evaluated>>"));
+  } catch (jsi::JSError &error) {
+    NSString *reason = [NSString stringWithUTF8String:error.getMessage().c_str()];
+    NSString *stack = [NSString stringWithUTF8String:error.getStack().c_str()];
+
+    @throw [NSException exceptionWithName:@"ScriptEvaluationException" reason:reason userInfo:@{
+      @"message": reason,
+      @"stack": stack,
+    }];
+  }
+  return [[EXJavaScriptValue alloc] initWithRuntime:self value:result];
+}
+
+#pragma mark - Private
+
+- (jsi::Function)createHostFunction:(nonnull NSString *)name
+                          argsCount:(NSInteger)argsCount
+                              block:(nonnull JSHostFunctionBlock)block
+{
+  jsi::PropNameID propNameId = jsi::PropNameID::forAscii(*_runtime, [name UTF8String], [name length]);
+  std::weak_ptr<react::CallInvoker> weakCallInvoker = _jsCallInvoker;
+  jsi::HostFunctionType function = [weakCallInvoker, block, self](jsi::Runtime &runtime, const jsi::Value &thisVal, const jsi::Value *args, size_t count) -> jsi::Value {
+    // Theoretically should check here whether the call invoker isn't null, but in mocked environment
+    // there is no need to care about that for synchronous calls, so it's ensured in `createAsyncFunction` instead.
+    auto callInvoker = weakCallInvoker.lock();
+    NSArray<EXJavaScriptValue *> *arguments = expo::convertJSIValuesToNSArray(self, args, count);
+    return block(runtime, callInvoker, arguments);
+  };
+  return jsi::Function::createFromHostFunction(*_runtime, propNameId, (unsigned int)argsCount, function);
+}
+
+@end

package/ios/JSI/EXJavaScriptValue.h

@@ -0,0 +1,57 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+#import <ExpoModulesCore/EXJavaScriptObject.h>
+
+#ifdef __cplusplus
+#import <jsi/jsi.h>
+namespace jsi = facebook::jsi;
+#endif // __cplusplus
+
+@class EXJavaScriptRuntime;
+
+/**
+ Represents any JavaScript value. Its purpose is to exposes `facebook::jsi::Value` API back to Swift.
+ */
+NS_SWIFT_NAME(JavaScriptValue)
+@interface EXJavaScriptValue : NSObject
+
+#ifdef __cplusplus
+- (nonnull instancetype)initWithRuntime:(nonnull EXJavaScriptRuntime *)runtime
+                                  value:(std::shared_ptr<jsi::Value>)value;
+
+/**
+ \return the underlying `jsi::Value`.
+ */
+- (nonnull jsi::Value *)get;
+#endif // __cplusplus
+
+#pragma mark - Type checking
+
+- (BOOL)isUndefined;
+- (BOOL)isNull;
+- (BOOL)isBool;
+- (BOOL)isNumber;
+- (BOOL)isString;
+- (BOOL)isSymbol;
+- (BOOL)isObject;
+- (BOOL)isFunction;
+
++ (nonnull NSString *)kindOf:(nonnull EXJavaScriptValue *)value;
+
+#pragma mark - Type casting
+
+- (nullable id)getRaw;
+- (BOOL)getBool;
+- (NSInteger)getInt;
+- (double)getDouble;
+- (nonnull NSString *)getString;
+- (nonnull NSArray<EXJavaScriptValue *> *)getArray;
+- (nonnull NSDictionary<NSString *, id> *)getDictionary;
+- (nonnull EXJavaScriptObject *)getObject;
+
+#pragma mark - Helpers
+
+- (nonnull NSString *)toString;
+
+@end

package/ios/JSI/EXJavaScriptValue.mm

@@ -0,0 +1,166 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXJSIConversions.h>
+#import <ExpoModulesCore/EXJavaScriptValue.h>
+#import <ExpoModulesCore/EXJavaScriptRuntime.h>
+
+@implementation EXJavaScriptValue {
+  __weak EXJavaScriptRuntime *_runtime;
+  std::shared_ptr<jsi::Value> _value;
+}
+
+- (nonnull instancetype)initWithRuntime:(nonnull EXJavaScriptRuntime *)runtime
+                                  value:(std::shared_ptr<jsi::Value>)value
+{
+  if (self = [super init]) {
+    _runtime = runtime;
+    _value = value;
+  }
+  return self;
+}
+
+- (nonnull jsi::Value *)get
+{
+  return _value.get();
+}
+
+#pragma mark - Type checking
+
+- (BOOL)isUndefined
+{
+  return _value->isUndefined();
+}
+
+- (BOOL)isNull
+{
+  return _value->isNull();
+}
+
+- (BOOL)isBool
+{
+  return _value->isBool();
+}
+
+- (BOOL)isNumber
+{
+  return _value->isNumber();
+}
+
+- (BOOL)isString
+{
+  return _value->isString();
+}
+
+- (BOOL)isSymbol
+{
+  return _value->isSymbol();
+}
+
+- (BOOL)isObject
+{
+  return _value->isObject();
+}
+
+- (BOOL)isFunction
+{
+  if (_value->isObject()) {
+    jsi::Runtime *runtime = [_runtime get];
+    return _value->getObject(*runtime).isFunction(*runtime);
+  }
+  return false;
+}
+
++ (nonnull NSString *)kindOf:(nonnull EXJavaScriptValue *)value
+{
+  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";
+  }
+  assert([value isObject] && "Expecting object.");
+  return @"object";
+}
+
+#pragma mark - Type casting
+
+- (nullable id)getRaw
+{
+  return expo::convertJSIValueToObjCObject(*[_runtime get], *_value, [_runtime callInvoker]);
+}
+
+- (BOOL)getBool
+{
+  return _value->getBool();
+}
+
+- (NSInteger)getInt
+{
+  return _value->getNumber();
+}
+
+- (double)getDouble
+{
+  return _value->getNumber();
+}
+
+- (nonnull NSString *)getString
+{
+  jsi::Runtime *runtime = [_runtime get];
+  return expo::convertJSIStringToNSString(*runtime, _value->getString(*runtime));
+}
+
+- (nonnull NSArray<EXJavaScriptValue *> *)getArray
+{
+  jsi::Runtime *runtime = [_runtime get];
+  jsi::Array jsiArray = _value->getObject(*runtime).getArray(*runtime);
+  size_t arraySize = jsiArray.size(*runtime);
+  NSMutableArray *result = [NSMutableArray arrayWithCapacity:arraySize];
+
+  for (size_t i = 0; i < arraySize; i++) {
+    jsi::Value item = jsiArray.getValueAtIndex(*runtime, i);
+
+    if (item.isUndefined() || item.isNull()) {
+      [result addObject:(id)kCFNull];
+    } else {
+      std::shared_ptr<jsi::Value> valuePtr = std::make_shared<jsi::Value>(*runtime, item);
+      [result addObject:[[EXJavaScriptValue alloc] initWithRuntime:_runtime value:valuePtr]];
+    }
+  }
+  return result;
+}
+
+- (nonnull NSDictionary<NSString *, id> *)getDictionary
+{
+  jsi::Runtime *runtime = [_runtime get];
+  return expo::convertJSIObjectToNSDictionary(*runtime, _value->getObject(*runtime), [_runtime callInvoker]);
+}
+
+- (nonnull EXJavaScriptObject *)getObject
+{
+  jsi::Runtime *runtime = [_runtime get];
+  std::shared_ptr<jsi::Object> objectPtr = std::make_shared<jsi::Object>(_value->asObject(*runtime));
+  return [[EXJavaScriptObject alloc] initWith:objectPtr runtime:_runtime];
+}
+
+#pragma mark - Helpers
+
+- (nonnull NSString *)toString
+{
+  jsi::Runtime *runtime = [_runtime get];
+  return expo::convertJSIStringToNSString(*runtime, _value->toString(*runtime));
+}
+
+@end

package/ios/JSI/ExpoModulesHostObject.h

@@ -0,0 +1,33 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#ifdef __cplusplus
+
+#import <vector>
+#import <jsi/jsi.h>
+
+namespace jsi = facebook::jsi;
+
+@class SwiftInteropBridge;
+
+namespace expo {
+
+class JSI_EXPORT ExpoModulesHostObject : public jsi::HostObject {
+public:
+  ExpoModulesHostObject(SwiftInteropBridge *interopBridge);
+
+  virtual ~ExpoModulesHostObject();
+
+  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:
+  SwiftInteropBridge *swiftInterop;
+
+}; // class ExpoModulesHostObject
+
+} // namespace expo
+
+#endif

package/ios/JSI/ExpoModulesHostObject.mm

@@ -0,0 +1,41 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/ExpoModulesHostObject.h>
+#import <ExpoModulesCore/EXJavaScriptObject.h>
+#import <ExpoModulesCore/Swift.h>
+
+namespace expo {
+
+ExpoModulesHostObject::ExpoModulesHostObject(SwiftInteropBridge *swiftInterop) : swiftInterop(swiftInterop) {}
+
+ExpoModulesHostObject::~ExpoModulesHostObject() {
+  [swiftInterop 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];
+
+  return nativeObject ? jsi::Value(runtime, *[nativeObject get]) : jsi::Value::undefined();
+}
+
+void ExpoModulesHostObject::set(jsi::Runtime &runtime, const jsi::PropNameID &name, const jsi::Value &value) {
+  std::string message("RuntimeError: Cannot override the host object for expo module '");
+  message += name.utf8(runtime);
+  message += "'.";
+  throw jsi::JSError(runtime, message);
+}
+
+std::vector<jsi::PropNameID> ExpoModulesHostObject::getPropertyNames(jsi::Runtime &runtime) {
+  NSArray<NSString *> *moduleNames = [swiftInterop getModuleNames];
+  std::vector<jsi::PropNameID> propertyNames;
+
+  propertyNames.reserve([moduleNames count]);
+
+  for (NSString *moduleName in moduleNames) {
+    propertyNames.push_back(jsi::PropNameID::forAscii(runtime, [moduleName UTF8String]));
+  }
+  return propertyNames;
+}
+
+} // namespace expo

package/ios/JSI/JavaScriptRuntime.swift

@@ -0,0 +1,32 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+public extension JavaScriptRuntime {
+  /**
+   Evaluates JavaScript code represented as a string.
+
+   - Parameter source: A string representing a JavaScript expression, statement, or sequence of statements.
+                       The expression can include variables and properties of existing objects.
+   - Returns: The completion value of evaluating the given code represented as `JavaScriptValue`.
+              If the completion value is empty, `undefined` is returned.
+   - Throws: `JavaScriptEvalException` when evaluated code has invalid syntax or throws an error.
+   - Note: It wraps the original `evaluateScript` to better handle and rethrow exceptions.
+   */
+  func eval(_ source: String) throws -> JavaScriptValue {
+    do {
+      var result: JavaScriptValue?
+      try EXUtilities.catchException {
+        result = self.evaluateScript(source)
+      }
+      // There is no risk to force unwrapping as long as the `evaluateScript` returns nonnull value.
+      return result!
+    } catch {
+      throw JavaScriptEvalException(error as NSError)
+    }
+  }
+}
+
+internal final class JavaScriptEvalException: GenericException<NSError> {
+  override var reason: String {
+    return param.userInfo["message"] as? String ?? "unknown reason"
+  }
+}

package/ios/JSI/JavaScriptValue.swift

@@ -0,0 +1,94 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Enum with available kinds of values. It's almost the same as a result of "typeof"
+ in JavaScript, however `null` has its own kind (typeof null == "object").
+ */
+public enum JavaScriptValueKind: String {
+  case undefined
+  case null
+  case bool
+  case number
+  case symbol
+  case string
+  case function
+  case object
+}
+
+public extension JavaScriptValue {
+  var kind: JavaScriptValueKind {
+    switch true {
+    case isUndefined():
+      return .undefined
+    case isNull():
+      return .null
+    case isBool():
+      return .bool
+    case isNumber():
+      return .number
+    case isSymbol():
+      return .symbol
+    case isString():
+      return .string
+    case isFunction():
+      return .function
+    default:
+      return .object
+    }
+  }
+
+  func asBool() throws -> Bool {
+    if isBool() {
+      return getBool()
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "Bool"))
+  }
+
+  func asInt() throws -> Int {
+    if isNumber() {
+      return getInt()
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "Int"))
+  }
+
+  func asDouble() throws -> Double {
+    if isNumber() {
+      return getDouble()
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "Double"))
+  }
+
+  func asString() throws -> String {
+    if isString() {
+      return getString()
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "String"))
+  }
+
+  func asArray() throws -> [JavaScriptValue?] {
+    if isObject() {
+      return getArray()
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "Array"))
+  }
+
+  func asDict() throws -> [String: Any] {
+    if isObject() {
+      return getDictionary()
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "Dict"))
+  }
+
+  func asObject() throws -> JavaScriptObject {
+    if isObject() {
+      return getObject()
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "Object"))
+  }
+}
+
+internal final class JavaScriptValueConversionException: GenericException<(kind: JavaScriptValueKind, target: String)> {
+  override var reason: String {
+    "Cannot represent a value of kind '\(param.kind)' as \(param.target)"
+  }
+}