expo-modules-core 0.9.2 → 0.10.0

package/ios/Tests/TypedArraysSpec.swift

@@ -0,0 +1,136 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+final class TypedArraysSpec: ExpoSpec {
+  override func spec() {
+    describe("module") {
+      let appContext = AppContext.create()
+      let runtime = appContext.runtime!
+
+      beforeSuite {
+        appContext.moduleRegistry.register(moduleType: TypedArraysModule.self)
+      }
+
+      // Gets the value at index 3 from the array
+      it("reads from Int8Array") {
+        let intValue = try runtime
+          .eval([
+            "typedArray = new Int8Array([2, 1, 3, 7])",
+            "ExpoModules.TypedArrays.int8_subscript_get(typedArray, 3)",
+          ])
+          .asInt()
+
+        expect(intValue) == 7
+      }
+
+      // Sets the value at index 1 to the random int
+      it("writes to Int8Array") {
+        let randomInt = Int.random(in: -128...127)
+        let array = try runtime
+          .eval([
+            "typedArray = new Int8Array(3)",
+            "ExpoModules.TypedArrays.int8_subscript_set(typedArray, 1, \(randomInt))",
+            "Array.from(typedArray)",
+          ])
+          .asArray()
+
+        expect(array[0]?.getInt()) == 0 // Remains unset
+        expect(array[1]?.getInt()) == randomInt
+        expect(array[2]?.getInt()) == 0 // Remains unset
+      }
+
+      // Gets a slice from the array from index 1 to 3
+      it("reads from UInt16Array slice") {
+        let values = try runtime
+          .eval([
+            "typedArray = new Uint16Array([0, 8, 4, 1])",
+            "ExpoModules.TypedArrays.uint16_subscript_range_get(typedArray, 1, 3)"
+          ])
+          .asArray()
+          .map({ try $0?.asInt() })
+
+        expect(values.count) == 3
+        expect(values[0]) == 8
+        expect(values[1]) == 4
+        expect(values[2]) == 1
+      }
+
+      // Sets a slice of the array from index x to y
+      it("writes to UInt16Array slice") {
+        let random1 = Int.random(in: 0...65535)
+        let random2 = Int.random(in: 0...65535)
+        let values = try runtime
+          .eval([
+            "typedArray = new Uint16Array(4)",
+            "ExpoModules.TypedArrays.uint16_subscript_range_set(typedArray, 1, 2, [\(random1), \(random2)])",
+            "Array.from(typedArray)",
+          ])
+          .asArray()
+
+        expect(values[0]?.getInt()) == 0 // Remains unset
+        expect(values[1]?.getInt()) == random1
+        expect(values[2]?.getInt()) == random2
+        expect(values[3]?.getInt()) == 0 // Remains unset
+      }
+
+      it("returns itself") {
+        let input = try runtime.eval("typedArray = new Float32Array([1.2, 3.4]); typedArray").asTypedArray()
+        let output = try runtime.eval("ExpoModules.TypedArrays.return(typedArray)").asTypedArray()
+
+        expect(input.getProperty("0").getDouble()) == output.getProperty("0").getDouble()
+        expect(input.getProperty("1").getDouble()) == output.getProperty("1").getDouble()
+        expect(input.getUnsafeMutableRawPointer()) == output.getUnsafeMutableRawPointer()
+      }
+
+      it("writes to unsafe raw pointer") {
+        let count = 6
+        let values = try runtime
+          .eval([
+            "typedArray = new Uint8Array(\(count))",
+            "Array.from(ExpoModules.TypedArrays.writeToUnsafeRawPointer(typedArray))",
+          ])
+          .asArray()
+          .map({ $0?.getInt() ?? 0 })
+
+        // Assume that at least one element should have changed
+        expect(values.filter({ $0 != 0 }).count) >= 1
+      }
+
+      // TODO: Test throwing NotTypedArrayException and ArrayTypeMismatchException
+    }
+  }
+}
+
+fileprivate final class TypedArraysModule: Module {
+  func definition() -> ModuleDefinition {
+    Name("TypedArrays")
+
+    Function("int8_subscript_get") { (array: Int8Array, index: Int) in
+      return array[index]
+    }
+
+    Function("int8_subscript_set") { (array: Int8Array, index: Int, value: Int8) in
+      array[index] = value
+    }
+
+    Function("uint16_subscript_range_get") { (array: Uint16Array, start: Int, end: Int) in
+      return array[start...end]
+    }
+
+    Function("uint16_subscript_range_set") { (array: Uint16Array, start: Int, end: Int, values: [UInt16]) in
+      array[start...end] = values
+    }
+
+    Function("return") { (array: TypedArray) -> JavaScriptTypedArray in
+      return array.jsTypedArray
+    }
+
+    Function("writeToUnsafeRawPointer") { (array: TypedArray) -> JavaScriptTypedArray in
+      let _ = SecRandomCopyBytes(kSecRandomDefault, array.byteLength, array.rawPointer)
+      return array.jsTypedArray
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "The core of Expo Modules architecture",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -42,5 +42,5 @@
     "@testing-library/react-hooks": "^7.0.1",
     "expo-module-scripts": "^2.0.0"
   },
-  "gitHead": "464933d2189a33b02375b47cd655e87f5694afb4"
+  "gitHead": "72253d4b18b62d329bbc6785d996e227f185d533"
 }

package/src/NativeModulesProxy.native.ts

@@ -2,15 +2,23 @@ import { NativeModules } from 'react-native';
 
 import { ProxyNativeModule } from './NativeModulesProxy.types';
 
-const NativeProxy = NativeModules.NativeUnimoduleProxy;
+const ExpoNativeProxy = global.ExpoModules?.NativeModulesProxy;
+const LegacyNativeProxy = NativeModules.NativeUnimoduleProxy;
+
 const modulesConstantsKey = 'modulesConstants';
 const exportedMethodsKey = 'exportedMethods';
 
 const NativeModulesProxy: { [moduleName: string]: ProxyNativeModule } = {};
 
-if (NativeProxy) {
+if (LegacyNativeProxy) {
+  // use JSI proxy if available, fallback to legacy RN proxy
+  const NativeProxy = ExpoNativeProxy ?? LegacyNativeProxy;
+
   Object.keys(NativeProxy[exportedMethodsKey]).forEach((moduleName) => {
+    // copy constants
     NativeModulesProxy[moduleName] = NativeProxy[modulesConstantsKey][moduleName] || {};
+
+    // copy methods
     NativeProxy[exportedMethodsKey][moduleName].forEach((methodInfo) => {
       NativeModulesProxy[moduleName][methodInfo.name] = (...args: unknown[]): Promise<any> => {
         const { key, argumentsCount } = methodInfo;
@@ -23,7 +31,9 @@ if (NativeProxy) {
             )
           );
         }
-        return NativeProxy.callMethod(moduleName, key, args);
+
+        // We still want to call methods using the legacy proxy in SDK 46
+        return LegacyNativeProxy.callMethod(moduleName, key, args);
       };
     });
 

package/src/ts-declarations/ExpoModules.d.ts

@@ -0,0 +1,7 @@
+declare let global: {
+  ExpoModules:
+    | undefined
+    | {
+        [key: string]: any;
+      };
+};

package/tsconfig.json

@@ -5,5 +5,5 @@
     "outDir": "./build"
   },
   "include": ["./src"],
-  "exclude": ["**/__mocks__/*", "**/__tests__/*"]
+  "exclude": ["**/__mocks__/*", "**/__tests__/*", "**/__stories__/*"]
 }

package/android/src/main/java/expo/modules/kotlin/functions/AsyncFunctionWithPromise.kt

@@ -1,15 +0,0 @@
-package expo.modules.kotlin.functions
-
-import expo.modules.kotlin.ModuleHolder
-import expo.modules.kotlin.Promise
-import expo.modules.kotlin.types.AnyType
-
-class AsyncFunctionWithPromise(
-  name: String,
-  argsType: Array<AnyType>,
-  private val body: (args: Array<out Any?>, promise: Promise) -> Unit
-) : AnyFunction(name, argsType) {
-  override fun callImplementation(holder: ModuleHolder, args: Array<out Any?>, promise: Promise) {
-    body(args, promise)
-  }
-}

package/android/src/main/java/expo/modules/kotlin/functions/AsyncSuspendFunction.kt

@@ -1,36 +0,0 @@
-package expo.modules.kotlin.functions
-
-import expo.modules.kotlin.ModuleHolder
-import expo.modules.kotlin.Promise
-import expo.modules.kotlin.exception.CodedException
-import expo.modules.kotlin.exception.FunctionCallException
-import expo.modules.kotlin.exception.UnexpectedException
-import expo.modules.kotlin.exception.exceptionDecorator
-import expo.modules.kotlin.types.AnyType
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
-
-class AsyncSuspendFunction(
-  name: String,
-  argsType: Array<AnyType>,
-  private val body: suspend CoroutineScope.(args: Array<out Any?>) -> Any?
-) : AnyFunction(name, argsType) {
-  override fun callImplementation(holder: ModuleHolder, args: Array<out Any?>, promise: Promise) {
-    val scope = holder.module.coroutineScopeDelegate.value
-    scope.launch {
-      try {
-        val result = exceptionDecorator({ cause -> FunctionCallException(name, holder.name, cause) }) {
-          body.invoke(scope, args)
-        }
-        if (isActive) {
-          promise.resolve(result)
-        }
-      } catch (e: CodedException) {
-        promise.reject(e)
-      } catch (e: Throwable) {
-        promise.reject(UnexpectedException(e))
-      }
-    }
-  }
-}

package/ios/Swift/Arguments/AnyArgumentType.swift

@@ -1,13 +0,0 @@
-// Copyright 2021-present 650 Industries. All rights reserved.
-
-/**
- A protocol whose intention is to wrap function's argument type
- to keep its real signature and not type-erase it by the compiler.
- */
-public protocol AnyArgumentType: CustomStringConvertible {
-  /**
-   Casts given any value to the wrapped type and returns as `Any`.
-   NOTE: It may not be just simple type-casting (e.g. when the wrapped type conforms to `ConvertibleArgument`).
-   */
-  func cast<ArgType>(_ value: ArgType) throws -> Any
-}

package/ios/Swift/Arguments/ArgumentType.swift

@@ -1,28 +0,0 @@
-// Copyright 2021-present 650 Industries. All rights reserved.
-
-// Function names should start with a lowercase character, but in this one case
-// we want it to be uppercase as we treat it more like a generic class.
-// swiftlint:disable identifier_name
-
-/**
- Factory creating an instance of the argument type wrapper conforming to `AnyArgumentType`.
- Depending on the given type, it may return one of `ArrayArgumentType`, `OptionalArgumentType`, `ConvertibleArgumentType`, etc.
- */
-internal func ArgumentType<T>(_ type: T.Type) -> AnyArgumentType {
-  if let ArrayType = T.self as? AnyArrayArgument.Type {
-    return ArrayArgumentType(elementType: ArrayType.getElementArgumentType())
-  }
-  if let OptionalType = T.self as? AnyOptionalArgument.Type {
-    return OptionalArgumentType(wrappedType: OptionalType.getWrappedArgumentType())
-  }
-  if let ConvertibleType = T.self as? ConvertibleArgument.Type {
-    return ConvertibleArgumentType(innerType: ConvertibleType)
-  }
-  if let EnumType = T.self as? EnumArgument.Type {
-    return EnumArgumentType(innerType: EnumType)
-  }
-  if T.self is Promise.Type {
-    return PromiseArgumentType()
-  }
-  return RawArgumentType(innerType: T.self)
-}

package/ios/Swift/Arguments/Types/ArrayArgumentType.swift

@@ -1,42 +0,0 @@
-// Copyright 2021-present 650 Industries. All rights reserved.
-
-/**
- An argument type representing array types. Requires the argument type for
- array's element type as it delegates casting to that type for each element in the array.
- */
-internal struct ArrayArgumentType: AnyArgumentType {
-  let elementType: AnyArgumentType
-
-  func cast<ArgType>(_ value: ArgType) throws -> Any {
-    if let value = value as? [Any] {
-      return try value.map { try elementType.cast($0) }
-    }
-    // We should probably throw an error if we get here. On the other side, the array type
-    // requirement can be more loosen so we can try to arrayize values that are not arrays.
-    return [try elementType.cast(value)]
-  }
-
-  var description: String {
-    "[\(elementType.description)]"
-  }
-}
-
-/**
- A type-erased protocol used to recognize arrays with elements of argument-compatible type.
- `Array` is a generic type, so it's impossible to check the inheritance directly.
- */
-internal protocol AnyArrayArgument: AnyArgument {
-  /**
-   Exposes the `Element` generic type wrapped by the argument type to preserve its metadata.
-   */
-  static func getElementArgumentType() -> AnyArgumentType
-}
-
-/**
- Extends the `Array` type to expose its generic `Element` as an argument type.
- */
-extension Array: AnyArrayArgument where Element: AnyArgument {
-  static func getElementArgumentType() -> AnyArgumentType {
-    return ArgumentType(Element.self)
-  }
-}

package/ios/Swift/Arguments/Types/ConvertibleArgumentType.swift

@@ -1,16 +0,0 @@
-// Copyright 2021-present 650 Industries. All rights reserved.
-
-/**
- An argument type that wraps any type conforming to `ConvertibleArgument` protocol.
- */
-internal struct ConvertibleArgumentType: AnyArgumentType {
-  let innerType: ConvertibleArgument.Type
-
-  func cast<ArgType>(_ value: ArgType) throws -> Any {
-    return try innerType.convert(from: value)
-  }
-
-  var description: String {
-    String(describing: innerType.self)
-  }
-}

package/ios/Swift/Arguments/Types/OptionalArgumentType.swift

@@ -1,49 +0,0 @@
-// Copyright 2021-present 650 Industries. All rights reserved.
-
-/**
- An argument type that represents an optional type, which allows `nil` to be passed when casting.
- Requires the argument type for optional's unwrapped type as it delegates casting to that type for non-nil values.
- */
-internal struct OptionalArgumentType: AnyArgumentType {
-  let wrappedType: AnyArgumentType
-
-  func cast<ArgType>(_ value: ArgType) throws -> Any {
-    if Optional.isNil(value) {
-      return Optional<Any>.none as Any
-    }
-    return try wrappedType.cast(value)
-  }
-
-  var description: String {
-    "\(wrappedType)?"
-  }
-}
-
-/**
- A type-erased protocol used to recognize if the generic type is an optional type.
- `Optional` is a generic enum, so it's impossible to check the inheritance directly.
- */
-internal protocol AnyOptionalArgument: AnyArgument {
-  /**
-   Exposes the `Wrapped` generic type wrapped by the argument type to preserve its metadata.`
-   */
-  static func getWrappedArgumentType() -> AnyArgumentType
-}
-
-/**
- Make generic `Optional` implement non-generic `AnyOptional` and add handy check against type-erased `nil`.
- */
-extension Optional: AnyOptionalArgument {
-  static func getWrappedArgumentType() -> AnyArgumentType {
-    return ArgumentType(Wrapped.self)
-  }
-
-  static func isNil(_ object: Wrapped) -> Bool {
-    switch object as Any {
-    case Optional<Any>.none:
-      return true
-    default:
-      return false
-    }
-  }
-}

package/ios/Swift/Arguments/Types/PromiseArgumentType.swift

@@ -1,15 +0,0 @@
-// Copyright 2021-present 650 Industries. All rights reserved.
-
-/**
- An argument type that represents the `Promise` argument.
- */
-internal struct PromiseArgumentType: AnyArgumentType {
-  func cast<ArgType>(_ value: ArgType) throws -> Any {
-    if let value = value as? Promise {
-      return value
-    }
-    throw Conversions.CastingException<Promise>(value)
-  }
-
-  var description: String = "Promise"
-}

package/ios/Swift/Arguments/Types/RawArgumentType.swift

@@ -1,25 +0,0 @@
-// Copyright 2021-present 650 Industries. All rights reserved.
-
-/**
- An argument type that can wrap any type, but it casts only type-compatible values using `as?` keyword.
- The innermost type of other argument types like `ArrayArgumentType` and `OptionalArgumentType`.
- */
-internal struct RawArgumentType<InnerType>: AnyArgumentType {
-  let innerType: InnerType.Type
-
-  func cast<ArgType>(_ value: ArgType) throws -> Any {
-    if let value = value as? InnerType {
-      return value
-    }
-    // Raw arguments are always non-optional, but they may receive `nil` values.
-    // Let's throw more specific error in this case.
-    if Optional.isNil(value) {
-      throw Conversions.NullCastException<InnerType>()
-    }
-    throw Conversions.CastingException<InnerType>(value)
-  }
-
-  var description: String {
-    String(describing: innerType.self)
-  }
-}

package/ios/Swift/Functions/ConcreteFunction.swift

@@ -1,103 +0,0 @@
-import Dispatch
-
-public class ConcreteFunction<Args, ReturnType>: AnyFunction {
-  public typealias ClosureType = (Args) throws -> ReturnType
-
-  public let name: String
-
-  public var takesPromise: Bool
-
-  public var argumentsCount: Int {
-    return argumentTypes.count
-  }
-
-  public var queue: DispatchQueue?
-
-  public var isAsync: Bool = true
-
-  let closure: ClosureType
-
-  public let argumentTypes: [AnyArgumentType]
-
-  init(
-    _ name: String,
-    argTypes: [AnyArgumentType],
-    _ closure: @escaping ClosureType
-  ) {
-    self.name = name
-    self.takesPromise = argTypes.last is PromiseArgumentType
-    self.closure = closure
-
-    // Drop the last argument type if it's the `Promise`.
-    self.argumentTypes = takesPromise ? argTypes.dropLast(1) : argTypes
-
-    // This is temporary solution to keep backwards compatibility for existing functions — they all end with "Async".
-    // `function` component that we've used so far was async by default, but we decided to replace it with `asyncFunction`
-    // and make `function`s synchronous. Introduced in SDK45, can be removed in SDK46 after migrating all modules.
-    self.isAsync = name.hasSuffix("Async")
-  }
-
-  /**
-   Calls the function with given arguments.
-   - Parameters:
-     - args: An array of arguments to pass to the function. The arguments must be of the same type as in the underlying ``closure``.
-     - promise: A promise to resolve or reject by the async ``closure`` when it finishes execution.
-   - ToDo: Make it internal.
-   */
-  public func call(args: [Any], promise: Promise) {
-    // Add promise to the array of arguments if necessary.
-    let arguments = takesPromise ? args + [promise] : args
-    let returnedValue: ReturnType?
-
-    do {
-      let argumentsTuple = try Conversions.toTuple(arguments) as! Args
-      returnedValue = try closure(argumentsTuple)
-    } catch let error as CodedError {
-      promise.reject(FunctionCallException(name).causedBy(error))
-      return
-    } catch {
-      promise.reject(UnexpectedException(error))
-      return
-    }
-    if !takesPromise {
-      promise.resolve(returnedValue)
-    }
-  }
-
-  /**
-   Calls the function synchronously with given arguments.
-   - Parameters:
-     - args: An array of arguments to pass to the function. The arguments must be of the same type as in the underlying ``closure``.
-   - Returns: A value returned by the called function when succeeded or an error when it failed.
-   - ToDo: Make it internal.
-   */
-  public func callSync(args: [Any]) -> Any {
-    if takesPromise {
-      // Using `Promise` in the synchronous function is prohibited. Probably should throw an exception here,
-      // but for now let's return nil until we split async and sync functions.
-      return Optional<Any>.none as Any
-    }
-    do {
-      let argumentsTuple = try Conversions.toTuple(args) as! Args
-      return try closure(argumentsTuple)
-    } catch let error {
-      return error
-    }
-  }
-
-  public func runOnQueue(_ queue: DispatchQueue?) -> Self {
-    self.queue = queue
-    return self
-  }
-
-  public func runSynchronously() -> Self {
-    self.isAsync = false
-    return self
-  }
-}
-
-internal class FunctionCallException: GenericException<String> {
-  override var reason: String {
-    "Call to function '\(param)' has been rejected"
-  }
-}