expo-modules-core 0.7.0 → 0.9.1

package/ios/ExpoModulesCore.h

@@ -1,5 +1,9 @@
 // Copyright 2015-present 650 Industries. All rights reserved.
 
+// Some headers needs to be imported from Objective-C code too.
+// Otherwise they won't be visible in `ExpoModulesCore-Swift.h`.
+#import <React/RCTView.h>
+
 #if __has_include("ExpoModulesCore-umbrella.h")
 #import "ExpoModulesCore-umbrella.h"
 #endif

package/ios/ExpoModulesCore.podspec

@@ -23,6 +23,9 @@ Pod::Spec.new do |s|
     'CLANG_CXX_LANGUAGE_STANDARD' => 'c++14',
     'SWIFT_COMPILATION_MODE' => 'wholemodule',
   }
+  s.user_target_xcconfig = {
+    "HEADER_SEARCH_PATHS" => "\"${PODS_CONFIGURATION_BUILD_DIR}/ExpoModulesCore/Swift Compatibility Header\"",
+  }
 
   s.dependency 'React-Core'
   s.dependency 'ReactCommon/turbomodule/core'
@@ -38,8 +41,7 @@ Pod::Spec.new do |s|
   s.private_header_files = ['**/*+Private.h', '**/Swift.h']
 
   s.test_spec 'Tests' do |test_spec|
-    test_spec.dependency 'Quick'
-    test_spec.dependency 'Nimble'
+    test_spec.dependency 'ExpoModulesTestCore'
 
     test_spec.source_files = 'Tests/**/*.{m,swift}'
   end

package/ios/Interfaces/FileSystem/EXFileSystemInterface.h

@@ -17,7 +17,7 @@ typedef NS_OPTIONS(unsigned int, EXFileSystemPermissionFlags) {
 
 // TODO: Move permissionsForURI to EXFileSystemManagerInterface
 - (EXFileSystemPermissionFlags)permissionsForURI:(NSURL *)uri;
-- (NSString *)generatePathInDirectory:(NSString *)directory withExtension:(NSString *)extension;
+- (nonnull NSString *)generatePathInDirectory:(NSString *)directory withExtension:(NSString *)extension;
 - (BOOL)ensureDirExistsWithPath:(NSString *)path;
 
 @end

package/ios/Interfaces/TaskManager/EXTaskServiceInterface.h

@@ -1,6 +1,7 @@
 // Copyright 2015-present 650 Industries. All rights reserved.
 
 #import <ExpoModulesCore/EXTaskInterface.h>
+#import <ExpoModulesCore/EXTaskManagerInterface.h>
 
 @protocol EXTaskServiceInterface
 

package/ios/JSI/{JSIConversions.h → EXJSIConversions.h}

@@ -11,6 +11,9 @@
 using namespace facebook;
 using namespace react;
 
+@class EXJavaScriptValue;
+@class EXJavaScriptRuntime;
+
 namespace expo {
 
 jsi::Value convertNSNumberToJSIBoolean(jsi::Runtime &runtime, NSNumber *value);
@@ -31,7 +34,7 @@ NSString *convertJSIStringToNSString(jsi::Runtime &runtime, const jsi::String &v
 
 NSArray *convertJSIArrayToNSArray(jsi::Runtime &runtime, const jsi::Array &value, std::shared_ptr<CallInvoker> jsInvoker);
 
-NSArray *convertJSIValuesToNSArray(jsi::Runtime &runtime, const jsi::Value *values, size_t count, std::shared_ptr<CallInvoker> jsInvoker);
+NSArray<EXJavaScriptValue *> *convertJSIValuesToNSArray(EXJavaScriptRuntime *runtime, const jsi::Value *values, size_t count);
 
 NSDictionary *convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value, std::shared_ptr<CallInvoker> jsInvoker);
 

package/ios/JSI/{JSIConversions.mm → EXJSIConversions.mm}

@@ -1,7 +1,9 @@
 // Copyright 2018-present 650 Industries. All rights reserved.
 
 #import <ReactCommon/TurboModuleUtils.h>
-#import <ExpoModulesCore/JSIConversions.h>
+#import <ExpoModulesCore/EXJSIConversions.h>
+#import <ExpoModulesCore/EXJavaScriptValue.h>
+#import <ExpoModulesCore/EXJavaScriptRuntime.h>
 
 namespace expo {
 
@@ -52,6 +54,12 @@ std::vector<jsi::Value> convertNSArrayToStdVector(jsi::Runtime &runtime, NSArray
 
 jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value)
 {
+  if ([value isKindOfClass:[EXJavaScriptValue class]]) {
+    return jsi::Value(runtime, *[(EXJavaScriptValue *)value get]);
+  }
+  if ([value isKindOfClass:[EXJavaScriptObject class]]) {
+    return jsi::Value(runtime, *[(EXJavaScriptObject *)value get]);
+  }
   if ([value isKindOfClass:[NSString class]]) {
     return convertNSStringToJSIString(runtime, (NSString *)value);
   } else if ([value isKindOfClass:[NSNumber class]]) {
@@ -86,13 +94,16 @@ NSArray *convertJSIArrayToNSArray(jsi::Runtime &runtime, const jsi::Array &value
   return [result copy];
 }
 
-NSArray *convertJSIValuesToNSArray(jsi::Runtime &runtime, const jsi::Value *values, size_t count, std::shared_ptr<CallInvoker> jsInvoker)
+NSArray<EXJavaScriptValue *> *convertJSIValuesToNSArray(EXJavaScriptRuntime *runtime, const jsi::Value *values, size_t count)
 {
-  NSMutableArray *result = [NSMutableArray arrayWithCapacity:count];
+  NSMutableArray<EXJavaScriptValue *> *array = [NSMutableArray arrayWithCapacity:count];
+  jsi::Runtime *jsiRuntime = [runtime get];
+
   for (int i = 0; i < count; i++) {
-    result[i] = convertJSIValueToObjCObject(runtime, values[i], jsInvoker);
+    std::shared_ptr<jsi::Value> value = std::make_shared<jsi::Value>(*jsiRuntime, values[i]);
+    array[i] = [[EXJavaScriptValue alloc] initWithRuntime:runtime value:value];
   }
-  return result;
+  return array;
 }
 
 NSDictionary *convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value, std::shared_ptr<CallInvoker> jsInvoker)

package/ios/JSI/{JSIInstaller.h → EXJSIInstaller.h}

@@ -18,12 +18,12 @@ void installRuntimeObjects(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> c
 
 #endif
 
-#import <ExpoModulesCore/JavaScriptRuntime.h>
+#import <ExpoModulesCore/EXJavaScriptRuntime.h>
 
 @class SwiftInteropBridge;
 
-@interface JavaScriptRuntimeManager : NSObject
+@interface EXJavaScriptRuntimeManager : NSObject
 
-+ (void)installExpoModulesToRuntime:(nonnull JavaScriptRuntime *)runtime withSwiftInterop:(nonnull SwiftInteropBridge *)swiftInterop;
++ (void)installExpoModulesToRuntime:(nonnull EXJavaScriptRuntime *)runtime withSwiftInterop:(nonnull SwiftInteropBridge *)swiftInterop;
 
 @end

package/ios/JSI/EXJSIInstaller.mm

@@ -0,0 +1,17 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXJSIInstaller.h>
+#import <ExpoModulesCore/ExpoModulesHostObject.h>
+#import <ExpoModulesCore/Swift.h>
+
+@implementation EXJavaScriptRuntimeManager
+
++ (void)installExpoModulesToRuntime:(nonnull EXJavaScriptRuntime *)runtime withSwiftInterop:(nonnull SwiftInteropBridge *)swiftInterop
+{
+  std::shared_ptr<expo::ExpoModulesHostObject> hostObjectPtr = std::make_shared<expo::ExpoModulesHostObject>(swiftInterop);
+  EXJavaScriptObject *global = [runtime global];
+
+  [global setProperty:@"ExpoModules" value:[runtime createHostObject:hostObjectPtr]];
+}
+
+@end

package/ios/JSI/{ExpoModulesProxySpec.h → EXJSIUtils.h}

@@ -5,8 +5,6 @@
 #import <jsi/jsi.h>
 #import <ReactCommon/RCTTurboModule.h>
 
-#import <ExpoModulesCore/EXNativeModulesProxy.h>
-
 using namespace facebook;
 using namespace react;
 
@@ -16,13 +14,6 @@ using PromiseInvocationBlock = void (^)(RCTPromiseResolveBlock resolveWrapper, R
 
 void callPromiseSetupWithBlock(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker, std::shared_ptr<Promise> promise, PromiseInvocationBlock setupBlock);
 
-class JSI_EXPORT ExpoModulesProxySpec : public TurboModule {
-public:
-  ExpoModulesProxySpec(std::shared_ptr<CallInvoker> callInvoker, EXNativeModulesProxy *nativeModulesProxy);
-
-  EXNativeModulesProxy *nativeModulesProxy;
-};
-
 } // namespace expo
 
 #endif

package/ios/JSI/{ExpoModulesProxySpec.mm → EXJSIUtils.mm}

@@ -1,9 +1,10 @@
-// Copyright 2018-present 650 Industries. All rights reserved.
+// Copyright 2022-present 650 Industries. All rights reserved.
 
 #import <React/RCTUtils.h>
+#import <ExpoModulesCore/EXJSIConversions.h>
+#import <ExpoModulesCore/EXJSIUtils.h>
 
-#import <ExpoModulesCore/JSIConversions.h>
-#import <ExpoModulesCore/ExpoModulesProxySpec.h>
+using namespace facebook;
 
 namespace expo {
 
@@ -85,49 +86,4 @@ void callPromiseSetupWithBlock(jsi::Runtime &runtime, std::shared_ptr<CallInvoke
   setupBlock(resolveBlock, rejectBlock);
 }
 
-static jsi::Value __hostFunction_ExpoModulesProxySpec_callMethodAsync(jsi::Runtime &runtime, TurboModule &turboModule, const jsi::Value *args, size_t count)
-{
-  auto expoModulesProxy = static_cast<ExpoModulesProxySpec *>(&turboModule);
-
-  // The function that is invoked as a setup of the JS `Promise`.
-  auto promiseSetupFunc = [expoModulesProxy, args](jsi::Runtime &runtime, std::shared_ptr<Promise> promise) {
-    callPromiseSetupWithBlock(runtime, expoModulesProxy->jsInvoker_, promise, ^(RCTPromiseResolveBlock resolver, RCTPromiseRejectBlock rejecter) {
-      NSString *moduleName = convertJSIStringToNSString(runtime, args[0].getString(runtime));
-      NSString *methodName = convertJSIStringToNSString(runtime, args[1].getString(runtime));
-      NSArray *arguments = convertJSIArrayToNSArray(runtime, args[2].getObject(runtime).asArray(runtime), expoModulesProxy->jsInvoker_);
-
-      [expoModulesProxy->nativeModulesProxy callMethod:moduleName
-                                       methodNameOrKey:methodName
-                                             arguments:arguments
-                                              resolver:resolver
-                                              rejecter:rejecter];
-    });
-  };
-
-  return createPromiseAsJSIValue(runtime, promiseSetupFunc);
-}
-
-static jsi::Value __hostFunction_ExpoModulesProxySpec_callMethodSync(jsi::Runtime &runtime, TurboModule &turboModule, const jsi::Value *args, size_t count)
-{
-  auto expoModulesProxy = static_cast<ExpoModulesProxySpec *>(&turboModule);
-  NSString *moduleName = convertJSIStringToNSString(runtime, args[0].getString(runtime));
-  NSString *methodName = convertJSIStringToNSString(runtime, args[1].getString(runtime));
-  NSArray *arguments = convertJSIArrayToNSArray(runtime, args[2].getObject(runtime).asArray(runtime), expoModulesProxy->jsInvoker_);
-
-  id result = [expoModulesProxy->nativeModulesProxy callMethodSync:moduleName
-                                                        methodName:methodName
-                                                         arguments:arguments];
-
-  return convertObjCObjectToJSIValue(runtime, result);
-}
-
-ExpoModulesProxySpec::ExpoModulesProxySpec(std::shared_ptr<CallInvoker> callInvoker, EXNativeModulesProxy *nativeModulesProxy) :
-  TurboModule("ExpoModulesProxy", callInvoker),
-  nativeModulesProxy(nativeModulesProxy)
-{
-  methodMap_["callMethodAsync"] = MethodMetadata {3, __hostFunction_ExpoModulesProxySpec_callMethodAsync};
-
-  methodMap_["callMethodSync"] = MethodMetadata {3, __hostFunction_ExpoModulesProxySpec_callMethodSync};
-}
-
 } // namespace expo

package/ios/JSI/EXJavaScriptObject.h

@@ -0,0 +1,97 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+
+#ifdef __cplusplus
+#import <jsi/jsi.h>
+#import <ReactCommon/CallInvoker.h>
+
+namespace jsi = facebook::jsi;
+#endif // __cplusplus
+
+typedef void (^JSAsyncFunctionBlock)(NSArray * _Nonnull, RCTPromiseResolveBlock _Nonnull, RCTPromiseRejectBlock _Nonnull);
+typedef id _Nullable (^JSSyncFunctionBlock)(NSArray * _Nonnull);
+
+@class EXJavaScriptRuntime;
+@class EXJavaScriptValue;
+
+/**
+ The property descriptor options for the property being defined or modified.
+ */
+typedef NS_OPTIONS(NSInteger, EXJavaScriptObjectPropertyDescriptor) {
+  /**
+   If set, the type of this property descriptor may be changed and if the property may be deleted from the corresponding object.
+   */
+  EXJavaScriptObjectPropertyDescriptorConfigurable = 1 << 0,
+  /**
+   If set, the property shows up during enumeration of the properties on the corresponding object.
+   */
+  EXJavaScriptObjectPropertyDescriptorEnumerable = 1 << 1,
+  /**
+   If set, the value associated with the property may be changed with an assignment operator.
+   */
+  EXJavaScriptObjectPropertyDescriptorWritable = 1 << 2,
+} NS_SWIFT_NAME(JavaScriptObjectPropertyDescriptor);
+
+NS_SWIFT_NAME(JavaScriptObject)
+@interface EXJavaScriptObject : NSObject
+
+// Some parts of the interface must be hidden for Swift – it can't import any C++ code.
+#ifdef __cplusplus
+- (nonnull instancetype)initWith:(std::shared_ptr<jsi::Object>)jsObjectPtr
+                         runtime:(nonnull EXJavaScriptRuntime *)runtime;
+
+/**
+ Returns the pointer to the underlying object.
+ */
+- (nonnull jsi::Object *)get;
+#endif // __cplusplus
+
+#pragma mark - Accessing object properties
+
+/**
+ \return a bool whether the object has a property with the given name.
+ */
+- (BOOL)hasProperty:(nonnull NSString *)name;
+
+/**
+ \return the property of the object with the given name.
+ If the name isn't a property on the object, returns the `undefined` value.
+ */
+- (nonnull EXJavaScriptValue *)getProperty:(nonnull NSString *)name;
+
+/**
+ \return an array consisting of all enumerable property names in the object and its prototype chain.
+ */
+- (nonnull NSArray<NSString *> *)getPropertyNames;
+
+#pragma mark - Modifying object properties
+
+/**
+ Sets the value for the property with the given name.
+ */
+- (void)setProperty:(nonnull NSString *)name value:(nullable id)value;
+
+/**
+ Defines a new property or modifies an existing property on the object. Calls `Object.defineProperty` under the hood.
+ */
+- (void)defineProperty:(nonnull NSString *)name value:(nullable id)value options:(EXJavaScriptObjectPropertyDescriptor)options;
+
+#pragma mark - Functions
+
+/**
+ Sets given function block on the object as a host function returning a promise.
+ */
+- (void)setAsyncFunction:(nonnull NSString *)key
+               argsCount:(NSInteger)argsCount
+                   block:(nonnull JSAsyncFunctionBlock)block;
+
+/**
+ Sets given synchronous function block as a host function on the object.
+ */
+- (void)setSyncFunction:(nonnull NSString *)name
+              argsCount:(NSInteger)argsCount
+                  block:(nonnull JSSyncFunctionBlock)block;
+
+@end

package/ios/JSI/EXJavaScriptObject.mm

@@ -0,0 +1,121 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXJSIConversions.h>
+#import <ExpoModulesCore/EXJavaScriptObject.h>
+#import <ExpoModulesCore/EXJavaScriptRuntime.h>
+
+@implementation EXJavaScriptObject {
+  /**
+   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 original JSI object that is being wrapped by `EXJavaScriptObject` class.
+   */
+  std::shared_ptr<jsi::Object> _jsObjectPtr;
+}
+
+- (nonnull instancetype)initWith:(std::shared_ptr<jsi::Object>)jsObjectPtr
+                         runtime:(nonnull EXJavaScriptRuntime *)runtime
+{
+  if (self = [super init]) {
+    _runtime = runtime;
+    _jsObjectPtr = jsObjectPtr;
+  }
+  return self;
+}
+
+- (nonnull jsi::Object *)get
+{
+  return _jsObjectPtr.get();
+}
+
+#pragma mark - Accessing object properties
+
+- (BOOL)hasProperty:(nonnull NSString *)name
+{
+  return _jsObjectPtr->hasProperty(*[_runtime get], [name UTF8String]);
+}
+
+- (nonnull EXJavaScriptValue *)getProperty:(nonnull NSString *)name
+{
+  std::shared_ptr<jsi::Value> value = std::make_shared<jsi::Value>(_jsObjectPtr->getProperty(*[_runtime get], [name UTF8String]));
+  return [[EXJavaScriptValue alloc] initWithRuntime:_runtime value:value];
+}
+
+- (nonnull NSArray<NSString *> *)getPropertyNames
+{
+  jsi::Runtime *runtime = [_runtime get];
+  jsi::Array propertyNamesArray = _jsObjectPtr->getPropertyNames(*[_runtime get]);
+  return expo::convertJSIArrayToNSArray(*runtime, propertyNamesArray, nullptr);
+}
+
+#pragma mark - Modifying object properties
+
+- (void)setProperty:(nonnull NSString *)name value:(nullable id)value
+{
+  jsi::Value jsiValue = expo::convertObjCObjectToJSIValue(*[_runtime get], value);
+  _jsObjectPtr->setProperty(*[_runtime get], [name UTF8String], jsiValue);
+}
+
+- (void)defineProperty:(nonnull NSString *)name value:(nullable id)value options:(EXJavaScriptObjectPropertyDescriptor)options
+{
+  jsi::Runtime *runtime = [_runtime get];
+  jsi::Object global = runtime->global();
+  jsi::Object objectClass = global.getPropertyAsObject(*runtime, "Object");
+  jsi::Function definePropertyFunction = objectClass.getPropertyAsFunction(*runtime, "defineProperty");
+  jsi::Object descriptor = [self preparePropertyDescriptorWithOptions:options];
+
+  descriptor.setProperty(*runtime, "value", expo::convertObjCObjectToJSIValue(*runtime, value));
+
+  // This call is basically the same as `Object.defineProperty(object, name, descriptor)` in JS
+  definePropertyFunction.callWithThis(*runtime, objectClass, {
+    jsi::Value(*runtime, *_jsObjectPtr.get()),
+    jsi::String::createFromUtf8(*runtime, [name UTF8String]),
+    std::move(descriptor),
+  });
+}
+
+#pragma mark - Functions
+
+- (void)setAsyncFunction:(nonnull NSString *)name
+               argsCount:(NSInteger)argsCount
+                   block:(nonnull JSAsyncFunctionBlock)block
+{
+  if (!_runtime) {
+    NSLog(@"Cannot set '%@' async function when the EXJavaScript runtime is no longer available.", name);
+    return;
+  }
+  jsi::Function function = [_runtime createAsyncFunction:name argsCount:argsCount block:block];
+  _jsObjectPtr->setProperty(*[_runtime get], [name UTF8String], function);
+}
+
+- (void)setSyncFunction:(nonnull NSString *)name
+              argsCount:(NSInteger)argsCount
+                  block:(nonnull JSSyncFunctionBlock)block
+{
+  if (!_runtime) {
+    NSLog(@"Cannot set '%@' sync function when the EXJavaScript runtime is no longer available.", name);
+    return;
+  }
+  jsi::Function function = [_runtime createSyncFunction:name argsCount:argsCount block:block];
+  _jsObjectPtr->setProperty(*[_runtime get], [name UTF8String], function);
+}
+
+#pragma mark - Private helpers
+
+- (jsi::Object)preparePropertyDescriptorWithOptions:(EXJavaScriptObjectPropertyDescriptor)options
+{
+  jsi::Runtime *runtime = [_runtime get];
+  jsi::Object descriptor(*runtime);
+  descriptor.setProperty(*runtime, "configurable", (bool)(options & EXJavaScriptObjectPropertyDescriptorConfigurable));
+  descriptor.setProperty(*runtime, "enumerable", (bool)(options & EXJavaScriptObjectPropertyDescriptorEnumerable));
+  descriptor.setProperty(*runtime, "writable", (bool)(options & EXJavaScriptObjectPropertyDescriptorWritable));
+  return descriptor;
+}
+
+@end

package/ios/JSI/{JavaScriptRuntime.h → EXJavaScriptRuntime.h}

@@ -1,6 +1,7 @@
 // Copyright 2018-present 650 Industries. All rights reserved.
 
-#import <ExpoModulesCore/JavaScriptObject.h>
+#import <ExpoModulesCore/EXJavaScriptValue.h>
+#import <ExpoModulesCore/EXJavaScriptObject.h>
 
 #ifdef __cplusplus
 #import <ReactCommon/CallInvoker.h>
@@ -9,12 +10,23 @@ namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 #endif // __cplusplus
 
-@interface JavaScriptRuntime : NSObject
+@class EXJavaScriptValue;
+@class EXJavaScriptObject;
 
 #ifdef __cplusplus
-typedef jsi::Value (^JSHostFunctionBlock)(jsi::Runtime &runtime, std::shared_ptr<react::CallInvoker> callInvoker, NSArray * _Nonnull arguments);
+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;
 
-- (nonnull instancetype)initWithRuntime:(jsi::Runtime &)runtime
+#ifdef __cplusplus
+- (nonnull instancetype)initWithRuntime:(nonnull jsi::Runtime *)runtime
                             callInvoker:(std::shared_ptr<react::CallInvoker>)callInvoker;
 
 /**
@@ -28,9 +40,9 @@ typedef jsi::Value (^JSHostFunctionBlock)(jsi::Runtime &runtime, std::shared_ptr
 - (std::shared_ptr<react::CallInvoker>)callInvoker;
 
 /**
- Wraps given host object to `JavaScriptObject`.
+ Wraps given host object to `EXJavaScriptObject`.
  */
-- (nonnull JavaScriptObject *)createHostObject:(std::shared_ptr<jsi::HostObject>)jsiHostObjectPtr;
+- (nonnull EXJavaScriptObject *)createHostObject:(std::shared_ptr<jsi::HostObject>)jsiHostObjectPtr;
 
 - (jsi::Function)createSyncFunction:(nonnull NSString *)name
                           argsCount:(NSInteger)argsCount
@@ -44,11 +56,18 @@ typedef jsi::Value (^JSHostFunctionBlock)(jsi::Runtime &runtime, std::shared_ptr
 /**
  Returns the runtime global object for use in Swift.
  */
-- (nonnull JavaScriptObject *)global;
+- (nonnull EXJavaScriptObject *)global;
 
 /**
  Creates a new object for use in Swift.
  */
-- (nonnull JavaScriptObject *)createObject;
+- (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