expo-modules-core 0.9.2 → 0.11.1

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

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