expo-modules-core 0.9.0 → 0.10.0

package/ios/ExpoModulesCore.podspec

@@ -34,7 +34,7 @@ Pod::Spec.new do |s|
     s.source_files = '**/*.h'
     s.vendored_frameworks = "#{s.name}.xcframework"
   else
-    s.source_files = '**/*.{h,m,mm,swift}'
+    s.source_files = '**/*.{h,m,mm,swift,cpp}'
   end
 
   s.exclude_files = 'Tests/'

package/ios/JSI/EXJSIConversions.mm

@@ -1,6 +1,9 @@
 // Copyright 2018-present 650 Industries. All rights reserved.
 
 #import <ReactCommon/TurboModuleUtils.h>
+#import <ExpoModulesCore/EXJavaScriptValue.h>
+#import <ExpoModulesCore/EXJavaScriptObject.h>
+#import <ExpoModulesCore/EXJavaScriptWeakObject.h>
 #import <ExpoModulesCore/EXJSIConversions.h>
 #import <ExpoModulesCore/EXJavaScriptValue.h>
 #import <ExpoModulesCore/EXJavaScriptRuntime.h>
@@ -60,6 +63,9 @@ jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value)
   if ([value isKindOfClass:[EXJavaScriptObject class]]) {
     return jsi::Value(runtime, *[(EXJavaScriptObject *)value get]);
   }
+  if ([value isKindOfClass:[EXJavaScriptWeakObject class]]) {
+    return jsi::Value(runtime, *[[(EXJavaScriptWeakObject *)value lock] get]);
+  }
   if ([value isKindOfClass:[NSString class]]) {
     return convertNSStringToJSIString(runtime, (NSString *)value);
   } else if ([value isKindOfClass:[NSNumber class]]) {

package/ios/JSI/EXJSIInstaller.h

@@ -1,29 +1,23 @@
 // Copyright 2018-present 650 Industries. All rights reserved.
 
-#ifdef __cplusplus
+#import <React/RCTBridge.h>
 
-#import <jsi/jsi.h>
-#import <ReactCommon/RCTTurboModule.h>
-
-#import <ExpoModulesCore/EXNativeModulesProxy.h>
-
-using namespace facebook;
-using namespace react;
-
-namespace expo {
-
-void installRuntimeObjects(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> callInvoker, EXNativeModulesProxy *nativeModulesProxy);
-
-} // namespace expo
-
-#endif
-
-#import <ExpoModulesCore/EXJavaScriptRuntime.h>
-
-@class SwiftInteropBridge;
+// Swift classes need forward-declaration in the headers.
+@class EXAppContext;
+@class EXJavaScriptRuntime;
 
 @interface EXJavaScriptRuntimeManager : NSObject
 
-+ (void)installExpoModulesToRuntime:(nonnull EXJavaScriptRuntime *)runtime withSwiftInterop:(nonnull SwiftInteropBridge *)swiftInterop;
+/**
+ Gets the JS runtime from the given bridge. May return `nil` when
+ the runtime is not available yet or the remote debugging is enabled.
+ */
++ (nullable EXJavaScriptRuntime *)runtimeFromBridge:(nonnull RCTBridge *)bridge NS_SWIFT_NAME(runtime(fromBridge:));
+
+/**
+ Installs ExpoModules host object in the runtime of the given app context.
+ Returns a bool value whether the installation succeeded.
+ */
++ (BOOL)installExpoModulesHostObject:(nonnull EXAppContext *)appContext;
 
 @end

package/ios/JSI/EXJSIInstaller.mm

@@ -4,14 +4,50 @@
 #import <ExpoModulesCore/ExpoModulesHostObject.h>
 #import <ExpoModulesCore/Swift.h>
 
+namespace jsi = facebook::jsi;
+
+/**
+ This name will be used as a property of the JS global object to which the host object is added.
+ */
+static NSString *expoModulesHostObjectPropertyName = @"ExpoModules";
+
+@interface RCTBridge (ExpoBridgeWithRuntime)
+
+- (void *)runtime;
+
+@end
+
 @implementation EXJavaScriptRuntimeManager
 
-+ (void)installExpoModulesToRuntime:(nonnull EXJavaScriptRuntime *)runtime withSwiftInterop:(nonnull SwiftInteropBridge *)swiftInterop
++ (nullable EXJavaScriptRuntime *)runtimeFromBridge:(nonnull RCTBridge *)bridge
 {
-  std::shared_ptr<expo::ExpoModulesHostObject> hostObjectPtr = std::make_shared<expo::ExpoModulesHostObject>(swiftInterop);
+  jsi::Runtime *jsiRuntime = [bridge respondsToSelector:@selector(runtime)] ? reinterpret_cast<jsi::Runtime *>(bridge.runtime) : nullptr;
+  return jsiRuntime ? [[EXJavaScriptRuntime alloc] initWithRuntime:jsiRuntime callInvoker:bridge.jsCallInvoker] : nil;
+}
+
++ (BOOL)installExpoModulesHostObject:(nonnull EXAppContext *)appContext
+{
+  EXJavaScriptRuntime *runtime = [appContext runtime];
+
+  // The runtime may be unavailable, e.g. remote debugger is enabled or it hasn't been set yet.
+  if (!runtime) {
+    return false;
+  }
+
   EXJavaScriptObject *global = [runtime global];
 
-  [global setProperty:@"ExpoModules" value:[runtime createHostObject:hostObjectPtr]];
+  if ([global hasProperty:expoModulesHostObjectPropertyName]) {
+    return false;
+  }
+
+  std::shared_ptr<expo::ExpoModulesHostObject> hostObjectPtr = std::make_shared<expo::ExpoModulesHostObject>(appContext);
+  EXJavaScriptObject *hostObject = [runtime createHostObject:hostObjectPtr];
+
+  // Define the ExpoModules object as a non-configurable, read-only and enumerable property.
+  [global defineProperty:expoModulesHostObjectPropertyName
+                   value:hostObject
+                 options:EXJavaScriptObjectPropertyDescriptorEnumerable];
+  return true;
 }
 
 @end

package/ios/JSI/EXJSIUtils.h

@@ -2,17 +2,61 @@
 
 #ifdef __cplusplus
 
+#import <functional>
+
 #import <jsi/jsi.h>
 #import <ReactCommon/RCTTurboModule.h>
+#import <ExpoModulesCore/EXObjectDeallocator.h>
 
-using namespace facebook;
-using namespace react;
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
 
 namespace expo {
 
+#pragma mark - Promises
+
 using PromiseInvocationBlock = void (^)(RCTPromiseResolveBlock resolveWrapper, RCTPromiseRejectBlock rejectWrapper);
 
-void callPromiseSetupWithBlock(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker, std::shared_ptr<Promise> promise, PromiseInvocationBlock setupBlock);
+void callPromiseSetupWithBlock(jsi::Runtime &runtime, std::shared_ptr<react::CallInvoker> jsInvoker, std::shared_ptr<react::Promise> promise, PromiseInvocationBlock setupBlock);
+
+#pragma mark - Classes
+
+using ClassConstructor = std::function<void(jsi::Runtime &runtime, const jsi::Value &thisValue, const jsi::Value *args, size_t count)>;
+
+std::shared_ptr<jsi::Function> createClass(jsi::Runtime &runtime, const char *name, ClassConstructor constructor);
+
+#pragma mark - Weak objects
+
+/**
+ Checks whether the `WeakRef` class is available in the given runtime.
+ According to the docs, it is unimplemented in JSC prior to iOS 14.5.
+ As of the time of writing this comment it's also unimplemented in Hermes
+ where you should use `jsi::WeakObject` instead.
+ https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef
+ */
+bool isWeakRefSupported(jsi::Runtime &runtime);
+
+/**
+ Creates the `WeakRef` with given JSI object. You should first use `isWeakRefSupported`
+ to check whether this feature is supported by the runtime.
+ */
+std::shared_ptr<jsi::Object> createWeakRef(jsi::Runtime &runtime, std::shared_ptr<jsi::Object> object);
+
+/**
+ Returns the `WeakRef` object's target object, or an empty pointer if the target object has been reclaimed.
+ */
+std::shared_ptr<jsi::Object> derefWeakRef(jsi::Runtime &runtime, std::shared_ptr<jsi::Object> object);
+
+#pragma mark - Define property
+
+void defineProperty(jsi::Runtime &runtime, const jsi::Object *object, const char *name, jsi::Value value);
+
+#pragma mark - Deallocator
+
+/**
+ Sets the deallocator block on a given object, which is called when the object is being deallocated.
+ */
+void setDeallocator(jsi::Runtime &runtime, std::shared_ptr<jsi::Object> object, ObjectDeallocatorBlock deallocatorBlock);
 
 } // namespace expo
 

package/ios/JSI/EXJSIUtils.mm

@@ -1,17 +1,17 @@
 // Copyright 2022-present 650 Industries. All rights reserved.
 
+#import <sstream>
+
 #import <React/RCTUtils.h>
 #import <ExpoModulesCore/EXJSIConversions.h>
 #import <ExpoModulesCore/EXJSIUtils.h>
 
-using namespace facebook;
-
 namespace expo {
 
 void callPromiseSetupWithBlock(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker, std::shared_ptr<Promise> promise, PromiseInvocationBlock setupBlock)
 {
-  auto weakResolveWrapper = CallbackWrapper::createWeak(promise->resolve_.getFunction(runtime), runtime, jsInvoker);
-  auto weakRejectWrapper = CallbackWrapper::createWeak(promise->reject_.getFunction(runtime), runtime, jsInvoker);
+  auto weakResolveWrapper = react::CallbackWrapper::createWeak(promise->resolve_.getFunction(runtime), runtime, jsInvoker);
+  auto weakRejectWrapper = react::CallbackWrapper::createWeak(promise->reject_.getFunction(runtime), runtime, jsInvoker);
 
   __block BOOL resolveWasCalled = NO;
   __block BOOL rejectWasCalled = NO;
@@ -86,4 +86,88 @@ void callPromiseSetupWithBlock(jsi::Runtime &runtime, std::shared_ptr<CallInvoke
   setupBlock(resolveBlock, rejectBlock);
 }
 
+std::shared_ptr<jsi::Function> createClass(jsi::Runtime &runtime, const char *name, ClassConstructor constructor) {
+  std::string nativeConstructorKey("__native_constructor__");
+
+  // Create a string buffer of the source code to evaluate.
+  std::stringstream source;
+  source << "(function " << name << "(...args) { this." << nativeConstructorKey << "(...args); return this; })";
+  std::shared_ptr<jsi::StringBuffer> sourceBuffer = std::make_shared<jsi::StringBuffer>(source.str());
+
+  // Evaluate the code and obtain returned value (the constructor function).
+  jsi::Object klass = runtime.evaluateJavaScript(sourceBuffer, "").asObject(runtime);
+
+  // Set the native constructor in the prototype.
+  jsi::Object prototype = klass.getPropertyAsObject(runtime, "prototype");
+  jsi::PropNameID nativeConstructorPropId = jsi::PropNameID::forAscii(runtime, nativeConstructorKey);
+  jsi::Function nativeConstructor = jsi::Function::createFromHostFunction(
+    runtime,
+    nativeConstructorPropId,
+    // The paramCount is not obligatory to match, it only affects the `length` property of the function.
+    0,
+    [constructor](jsi::Runtime &runtime, const jsi::Value &thisValue, const jsi::Value *args, size_t count) -> jsi::Value {
+      constructor(runtime, thisValue, args, count);
+      return jsi::Value::undefined();
+    });
+
+  defineProperty(runtime, &prototype, nativeConstructorKey.c_str(), jsi::Value(runtime, nativeConstructor));
+
+  return std::make_shared<jsi::Function>(klass.asFunction(runtime));
+}
+
+#pragma mark - Weak objects
+
+bool isWeakRefSupported(jsi::Runtime &runtime) {
+  return runtime.global().hasProperty(runtime, "WeakRef");
+}
+
+std::shared_ptr<jsi::Object> createWeakRef(jsi::Runtime &runtime, std::shared_ptr<jsi::Object> object) {
+  jsi::Object weakRef = runtime
+    .global()
+    .getProperty(runtime, "WeakRef")
+    .asObject(runtime)
+    .asFunction(runtime)
+    .callAsConstructor(runtime, jsi::Value(runtime, *object))
+    .asObject(runtime);
+  return std::make_shared<jsi::Object>(std::move(weakRef));
+}
+
+std::shared_ptr<jsi::Object> derefWeakRef(jsi::Runtime &runtime, std::shared_ptr<jsi::Object> object) {
+  jsi::Value ref = object->getProperty(runtime, "deref")
+    .asObject(runtime)
+    .asFunction(runtime)
+    .callWithThis(runtime, *object);
+
+  if (ref.isUndefined()) {
+    return nullptr;
+  }
+  return std::make_shared<jsi::Object>(ref.asObject(runtime));
+}
+
+#pragma mark - Define property
+
+void defineProperty(jsi::Runtime &runtime, const jsi::Object *object, const char *name, jsi::Value value) {
+  jsi::Object global = runtime.global();
+  jsi::Object objectClass = global.getPropertyAsObject(runtime, "Object");
+  jsi::Function definePropertyFunction = objectClass.getPropertyAsFunction(runtime, "defineProperty");
+
+  jsi::Object descriptor(runtime);
+  descriptor.setProperty(runtime, "value", value);
+
+  definePropertyFunction.callWithThis(runtime, objectClass, {
+    jsi::Value(runtime, *object),
+    jsi::String::createFromUtf8(runtime, name),
+    std::move(descriptor),
+  });
+}
+
+#pragma mark - Deallocator
+
+void setDeallocator(jsi::Runtime &runtime, std::shared_ptr<jsi::Object> object, ObjectDeallocatorBlock deallocatorBlock) {
+  std::shared_ptr<expo::ObjectDeallocator> hostObjectPtr = std::make_shared<ObjectDeallocator>(deallocatorBlock);
+  jsi::Object jsObject = jsi::Object::createFromHostObject(runtime, hostObjectPtr);
+
+  object->setProperty(runtime, "__expo_object_deallocator__", jsi::Value(runtime, jsObject));
+}
+
 } // namespace expo

package/ios/JSI/EXJavaScriptObject.h

@@ -1,20 +1,16 @@
 // 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;
+@class EXJavaScriptWeakObject;
 
 /**
  The property descriptor options for the property being defined or modified.
@@ -73,25 +69,22 @@ NS_SWIFT_NAME(JavaScriptObject)
  */
 - (void)setProperty:(nonnull NSString *)name value:(nullable id)value;
 
+/**
+ Defines a new property or modifies an existing property on the object using the property descriptor.
+ */
+- (void)defineProperty:(nonnull NSString *)name descriptor:(nonnull EXJavaScriptObject *)descriptor;
+
 /**
  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
+#pragma mark - WeakObject
 
-/**
- 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;
+- (nonnull EXJavaScriptWeakObject *)createWeak;
 
-/**
- Sets given synchronous function block as a host function on the object.
- */
-- (void)setSyncFunction:(nonnull NSString *)name
-              argsCount:(NSInteger)argsCount
-                  block:(nonnull JSSyncFunctionBlock)block;
+#pragma mark - Deallocator
+
+- (void)setObjectDeallocator:(void (^ _Nonnull)(void))deallocatorBlock;
 
 @end

package/ios/JSI/EXJavaScriptObject.mm

@@ -1,8 +1,11 @@
 // Copyright 2022-present 650 Industries. All rights reserved.
 
 #import <ExpoModulesCore/EXJSIConversions.h>
+#import <ExpoModulesCore/EXJavaScriptValue.h>
 #import <ExpoModulesCore/EXJavaScriptObject.h>
 #import <ExpoModulesCore/EXJavaScriptRuntime.h>
+#import <ExpoModulesCore/EXJavaScriptWeakObject.h>
+#import <ExpoModulesCore/EXJSIUtils.h>
 
 @implementation EXJavaScriptObject {
   /**
@@ -62,6 +65,21 @@
   _jsObjectPtr->setProperty(*[_runtime get], [name UTF8String], jsiValue);
 }
 
+- (void)defineProperty:(nonnull NSString *)name descriptor:(nonnull EXJavaScriptObject *)descriptor
+{
+  jsi::Runtime *runtime = [_runtime get];
+  jsi::Object global = runtime->global();
+  jsi::Object objectClass = global.getPropertyAsObject(*runtime, "Object");
+  jsi::Function definePropertyFunction = objectClass.getPropertyAsFunction(*runtime, "defineProperty");
+
+  // 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 get]),
+  });
+}
+
 - (void)defineProperty:(nonnull NSString *)name value:(nullable id)value options:(EXJavaScriptObjectPropertyDescriptor)options
 {
   jsi::Runtime *runtime = [_runtime get];
@@ -80,30 +98,31 @@
   });
 }
 
-#pragma mark - Functions
+#pragma mark - WeakObject
 
-- (void)setAsyncFunction:(nonnull NSString *)name
-               argsCount:(NSInteger)argsCount
-                   block:(nonnull JSAsyncFunctionBlock)block
+- (nonnull EXJavaScriptWeakObject *)createWeak
 {
-  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);
+  return [[EXJavaScriptWeakObject alloc] initWith:_jsObjectPtr runtime:_runtime];
 }
 
-- (void)setSyncFunction:(nonnull NSString *)name
-              argsCount:(NSInteger)argsCount
-                  block:(nonnull JSSyncFunctionBlock)block
+#pragma mark - Deallocator
+
+- (void)setObjectDeallocator:(void (^)(void))deallocatorBlock
+{
+  expo::setDeallocator(*[_runtime get], _jsObjectPtr, deallocatorBlock);
+}
+
+#pragma mark - Equality
+
+- (BOOL)isEqual:(id)object
 {
-  if (!_runtime) {
-    NSLog(@"Cannot set '%@' sync function when the EXJavaScript runtime is no longer available.", name);
-    return;
+  if ([object isKindOfClass:EXJavaScriptObject.class]) {
+    jsi::Runtime *runtime = [_runtime get];
+    jsi::Object *a = _jsObjectPtr.get();
+    jsi::Object *b = [object get];
+    return jsi::Object::strictEquals(*runtime, *a, *b);
   }
-  jsi::Function function = [_runtime createSyncFunction:name argsCount:argsCount block:block];
-  _jsObjectPtr->setProperty(*[_runtime get], [name UTF8String], function);
+  return false;
 }
 
 #pragma mark - Private helpers

package/ios/JSI/EXJavaScriptRuntime.h

@@ -1,7 +1,9 @@
 // Copyright 2018-present 650 Industries. All rights reserved.
 
+#import <Foundation/Foundation.h>
 #import <ExpoModulesCore/EXJavaScriptValue.h>
 #import <ExpoModulesCore/EXJavaScriptObject.h>
+#import <React/RCTBridgeModule.h>
 
 #ifdef __cplusplus
 #import <ReactCommon/CallInvoker.h>
@@ -13,8 +15,20 @@ namespace react = facebook::react;
 @class EXJavaScriptValue;
 @class EXJavaScriptObject;
 
+typedef void (^JSAsyncFunctionBlock)(EXJavaScriptValue * _Nonnull thisValue,
+                                     NSArray<EXJavaScriptValue *> * _Nonnull arguments,
+                                     RCTPromiseResolveBlock _Nonnull resolve,
+                                     RCTPromiseRejectBlock _Nonnull reject);
+
+typedef id _Nullable (^JSSyncFunctionBlock)(EXJavaScriptValue * _Nonnull thisValue,
+                                            NSArray<EXJavaScriptValue *> * _Nonnull arguments,
+                                            NSError * _Nullable __autoreleasing * _Nullable error);
+
 #ifdef __cplusplus
-typedef jsi::Value (^JSHostFunctionBlock)(jsi::Runtime &runtime, std::shared_ptr<react::CallInvoker> callInvoker, NSArray<EXJavaScriptValue *> * _Nonnull arguments);
+typedef jsi::Value (^JSHostFunctionBlock)(jsi::Runtime &runtime,
+                                          std::shared_ptr<react::CallInvoker> callInvoker,
+                                          EXJavaScriptValue * _Nonnull thisValue,
+                                          NSArray<EXJavaScriptValue *> * _Nonnull arguments);
 #endif // __cplusplus
 
 NS_SWIFT_NAME(JavaScriptRuntime)
@@ -26,6 +40,7 @@ NS_SWIFT_NAME(JavaScriptRuntime)
 - (nonnull instancetype)init;
 
 #ifdef __cplusplus
+
 - (nonnull instancetype)initWithRuntime:(nonnull jsi::Runtime *)runtime
                             callInvoker:(std::shared_ptr<react::CallInvoker>)callInvoker;
 
@@ -44,13 +59,6 @@ NS_SWIFT_NAME(JavaScriptRuntime)
  */
 - (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
 
 /**
@@ -63,11 +71,37 @@ NS_SWIFT_NAME(JavaScriptRuntime)
  */
 - (nonnull EXJavaScriptObject *)createObject;
 
+/**
+ Creates a synchronous host function that runs given block when it's called.
+ The value returned by the block is synchronously returned to JS.
+ \return A JavaScript function represented as a `JavaScriptObject`.
+ */
+- (nonnull EXJavaScriptObject *)createSyncFunction:(nonnull NSString *)name
+                                         argsCount:(NSInteger)argsCount
+                                             block:(nonnull JSSyncFunctionBlock)block NS_REFINED_FOR_SWIFT;
+
+/**
+ Creates an asynchronous host function that runs given block when it's called.
+ The block receives a resolver that you should call when the asynchronous operation
+ succeeds and a rejecter to call whenever it fails.
+ \return A JavaScript function represented as a `JavaScriptObject`.
+ */
+- (nonnull EXJavaScriptObject *)createAsyncFunction:(nonnull NSString *)name
+                                          argsCount:(NSInteger)argsCount
+                                              block:(nonnull JSAsyncFunctionBlock)block;
+
+#pragma mark - Classes
+
+typedef void (^ClassConstructorBlock)(EXJavaScriptObject * _Nonnull thisValue, NSArray<EXJavaScriptValue *> * _Nonnull arguments);
+
+- (nonnull EXJavaScriptObject *)createClass:(nonnull NSString *)name
+                                constructor:(nonnull ClassConstructorBlock)constructor;
+
 #pragma mark - Script evaluation
 
 /**
  Evaluates given JavaScript source code.
  */
-- (nonnull EXJavaScriptValue *)evaluateScript:(nonnull NSString *)scriptSource;
+- (nonnull EXJavaScriptValue *)evaluateScript:(nonnull NSString *)scriptSource NS_REFINED_FOR_SWIFT;
 
 @end

package/ios/JSI/EXJavaScriptRuntime.mm

@@ -82,33 +82,66 @@ using namespace facebook;
   return [[EXJavaScriptObject alloc] initWith:jsGlobalPtr runtime:self];
 }
 
-- (jsi::Function)createSyncFunction:(nonnull NSString *)name
-                          argsCount:(NSInteger)argsCount
-                              block:(nonnull JSSyncFunctionBlock)block
+- (nonnull EXJavaScriptObject *)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));
-  }];
+  JSHostFunctionBlock hostFunctionBlock = ^jsi::Value(
+    jsi::Runtime &runtime,
+    std::shared_ptr<react::CallInvoker> callInvoker,
+    EXJavaScriptValue * _Nonnull thisValue,
+    NSArray<EXJavaScriptValue *> * _Nonnull arguments) {
+      NSError *error;
+      id result = block(thisValue, arguments, &error);
+
+      if (error == nil) {
+        return expo::convertObjCObjectToJSIValue(runtime, result);
+      } else {
+        throw jsi::JSError(runtime, [error.userInfo[@"message"] UTF8String]);
+      }
+    };
+  return [self createHostFunction:name argsCount:argsCount block:hostFunctionBlock];
 }
 
-- (jsi::Function)createAsyncFunction:(nonnull NSString *)name
-                           argsCount:(NSInteger)argsCount
-                               block:(nonnull JSAsyncFunctionBlock)block
+- (nonnull EXJavaScriptObject *)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);
-      });
+  JSHostFunctionBlock hostFunctionBlock = ^jsi::Value(
+    jsi::Runtime &runtime,
+    std::shared_ptr<react::CallInvoker> callInvoker,
+    EXJavaScriptValue * _Nonnull thisValue,
+    NSArray<EXJavaScriptValue *> * _Nonnull 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, thisValue, arguments](jsi::Runtime &runtime, std::shared_ptr<Promise> promise) {
+        expo::callPromiseSetupWithBlock(runtime, callInvoker, promise, ^(RCTPromiseResolveBlock resolver, RCTPromiseRejectBlock rejecter) {
+          block(thisValue, arguments, resolver, rejecter);
+        });
+      };
+      return createPromiseAsJSIValue(runtime, promiseSetup);
     };
-    return createPromiseAsJSIValue(runtime, promiseSetup);
-  }];
+  return [self createHostFunction:name argsCount:argsCount block:hostFunctionBlock];
+}
+
+#pragma mark - Classes
+
+- (nonnull EXJavaScriptObject *)createClass:(nonnull NSString *)name
+                                constructor:(nonnull ClassConstructorBlock)constructor
+{
+  expo::ClassConstructor jsConstructor = [self, constructor](jsi::Runtime &runtime, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    std::shared_ptr<jsi::Object> thisPtr = std::make_shared<jsi::Object>(thisValue.asObject(runtime));
+    EXJavaScriptObject *caller = [[EXJavaScriptObject alloc] initWith:thisPtr runtime:self];
+    NSArray<EXJavaScriptValue *> *arguments = expo::convertJSIValuesToNSArray(self, args, count);
+
+    constructor(caller, arguments);
+  };
+  std::shared_ptr<jsi::Function> klass = expo::createClass(*_runtime, [name UTF8String], jsConstructor);
+  return [[EXJavaScriptObject alloc] initWith:klass runtime:self];
 }
 
 #pragma mark - Script evaluation
@@ -128,15 +161,21 @@ using namespace facebook;
       @"message": reason,
       @"stack": stack,
     }];
+  } catch (jsi::JSIException &error) {
+    NSString *reason = [NSString stringWithUTF8String:error.what()];
+    
+    @throw [NSException exceptionWithName:@"ScriptEvaluationException" reason:reason userInfo:@{
+      @"message": reason
+    }];
   }
   return [[EXJavaScriptValue alloc] initWithRuntime:self value:result];
 }
 
 #pragma mark - Private
 
-- (jsi::Function)createHostFunction:(nonnull NSString *)name
-                          argsCount:(NSInteger)argsCount
-                              block:(nonnull JSHostFunctionBlock)block
+- (nonnull EXJavaScriptObject *)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;
@@ -145,9 +184,13 @@ using namespace facebook;
     // 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);
+    std::shared_ptr<jsi::Value> thisValPtr = std::make_shared<jsi::Value>(runtime, std::move(thisVal));
+    EXJavaScriptValue *thisValue = [[EXJavaScriptValue alloc] initWithRuntime:self value:thisValPtr];
+
+    return block(runtime, callInvoker, thisValue, arguments);
   };
-  return jsi::Function::createFromHostFunction(*_runtime, propNameId, (unsigned int)argsCount, function);
+  std::shared_ptr<jsi::Object> fnPtr = std::make_shared<jsi::Object>(jsi::Function::createFromHostFunction(*_runtime, propNameId, (unsigned int)argsCount, function));
+  return [[EXJavaScriptObject alloc] initWith:fnPtr runtime:self];
 }
 
 @end