expo-modules-core 1.1.0 → 1.2.0

package/ios/Swift/Functions/ConcurrentFunctionDefinition.swift

@@ -0,0 +1,271 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Represents a concurrent function that can only be called asynchronously, thus its JavaScript equivalent returns a Promise.
+ As opposed to `AsyncFunctionComponent`, it can leverage the new Swift's concurrency model and take the async/await closure.
+ */
+public final class ConcurrentFunctionDefinition<Args, FirstArgType, ReturnType>: AnyFunction {
+  typealias ClosureType = (Args) async throws -> ReturnType
+
+  let body: ClosureType
+
+  init(
+    _ name: String,
+    firstArgType: FirstArgType.Type,
+    dynamicArgumentTypes: [AnyDynamicType],
+    _ body: @escaping ClosureType
+  ) {
+    self.name = name
+    self.body = body
+    self.dynamicArgumentTypes = dynamicArgumentTypes
+  }
+
+  // MARK: - AnyFunction
+
+  let name: String
+
+  let dynamicArgumentTypes: [AnyDynamicType]
+
+  var takesOwner: Bool = false
+
+  func call(by owner: AnyObject?, withArguments args: [Any], callback: @escaping (FunctionCallResult) -> Void) {
+    let arguments: [Any]
+
+    do {
+      arguments = concat(
+        arguments: try cast(arguments: args, forFunction: self),
+        withOwner: owner,
+        forFunction: self
+      )
+    } catch let error as Exception {
+      callback(.failure(error))
+      return
+    } catch {
+      callback(.failure(UnexpectedException(error)))
+      return
+    }
+
+    // Switch from the synchronous context to asynchronous
+    Task { [arguments] in
+      let result: Result<Any, Exception>
+
+      do {
+        // TODO: Right now we force cast the tuple in all types of functions, but we should throw another exception here.
+        // swiftlint:disable force_cast
+        let argumentsTuple = try Conversions.toTuple(arguments) as! Args
+        let returnValue = try await body(argumentsTuple)
+
+        result = .success(returnValue)
+      } catch let error as Exception {
+        result = .failure(FunctionCallException(name).causedBy(error))
+      } catch {
+        result = .failure(UnexpectedException(error))
+      }
+
+      callback(result)
+    }
+  }
+
+  // MARK: - JavaScriptObjectBuilder
+
+  func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
+    return runtime.createAsyncFunction(name, argsCount: argumentsCount) { [weak self, name] this, args, resolve, reject in
+      guard let self = self else {
+        let exception = NativeFunctionUnavailableException(name)
+        return reject(exception.code, exception.description, nil)
+      }
+      self.call(by: this, withArguments: args) { result in
+        switch result {
+        case .failure(let error):
+          reject(error.code, error.description, nil)
+        case .success(let value):
+          resolve(value)
+        }
+      }
+    }
+  }
+}
+
+/**
+ Concurrently-executing asynchronous function without arguments.
+ */
+public func AsyncFunction<R>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping () async throws -> R
+) -> ConcurrentFunctionDefinition<(), Void, R> {
+  return ConcurrentFunctionDefinition(
+    name,
+    firstArgType: Void.self,
+    dynamicArgumentTypes: [],
+    closure
+  )
+}
+
+/**
+ Concurrently-executing asynchronous function with one argument.
+ */
+public func AsyncFunction<R, A0: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0) async throws -> R
+) -> ConcurrentFunctionDefinition<(A0), A0, R> {
+  return ConcurrentFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [~A0.self],
+    closure
+  )
+}
+
+/**
+ Concurrently-executing asynchronous function with two arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1) async throws -> R
+) -> ConcurrentFunctionDefinition<(A0, A1), A0, R> {
+  return ConcurrentFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [~A0.self, ~A1.self],
+    closure
+  )
+}
+
+/**
+ Concurrently-executing asynchronous function with three arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2) async throws -> R
+) -> ConcurrentFunctionDefinition<(A0, A1, A2), A0, R> {
+  return ConcurrentFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self
+    ],
+    closure
+  )
+}
+
+/**
+ Concurrently-executing asynchronous function with four arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3) async throws -> R
+) -> ConcurrentFunctionDefinition<(A0, A1, A2, A3), A0, R> {
+  return ConcurrentFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self
+    ],
+    closure
+  )
+}
+
+/**
+ Concurrently-executing asynchronous function with five arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4) async throws -> R
+) -> ConcurrentFunctionDefinition<(A0, A1, A2, A3, A4), A0, R> {
+  return ConcurrentFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self
+    ],
+    closure
+  )
+}
+
+/**
+ Concurrently-executing asynchronous function with six arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4, A5) async throws -> R
+) -> ConcurrentFunctionDefinition<(A0, A1, A2, A3, A4, A5), A0, R> {
+  return ConcurrentFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self
+    ],
+    closure
+  )
+}
+
+/**
+ Concurrently-executing asynchronous function with seven arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6) async throws -> R
+) -> ConcurrentFunctionDefinition<(A0, A1, A2, A3, A4, A5, A6), A0, R> {
+  return ConcurrentFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self,
+      ~A6.self
+    ],
+    closure
+  )
+}
+
+/**
+ Concurrently-executing asynchronous function with eight arguments.
+ */
+public func AsyncFunction<
+  R,
+  A0: AnyArgument,
+  A1: AnyArgument,
+  A2: AnyArgument,
+  A3: AnyArgument,
+  A4: AnyArgument,
+  A5: AnyArgument,
+  A6: AnyArgument,
+  A7: AnyArgument
+>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6, A7) async throws -> R
+) -> ConcurrentFunctionDefinition<(A0, A1, A2, A3, A4, A5, A6, A7), A0, R> {
+  return ConcurrentFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self,
+      ~A6.self,
+      ~A7.self
+    ],
+    closure
+  )
+}

package/ios/Swift/Functions/SyncFunctionComponent.swift

@@ -82,12 +82,16 @@ public final class SyncFunctionComponent<Args, FirstArgType, ReturnType>: AnySyn
   // MARK: - JavaScriptObjectBuilder
 
   func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    return runtime.createSyncFunction(name, argsCount: argumentsCount) { [weak self, name] this, args in
-      guard let self = self else {
-        throw NativeFunctionUnavailableException(name)
+    // We intentionally capture a strong reference to `self`, otherwise the "detached" objects would
+    // immediately lose the reference to the definition and thus the underlying native function.
+    // It may potentially cause memory leaks, but at the time of writing this comment,
+    // the native definition instance deallocates correctly when the JS VM triggers the garbage collector.
+    return runtime.createSyncFunction(name, argsCount: argumentsCount) { [weak runtime, self] this, args in
+      guard let runtime = runtime else {
+        throw Exceptions.RuntimeLost()
       }
       let result = try self.call(by: this, withArguments: args)
-      return Conversions.convertFunctionResult(result)
+      return Conversions.convertFunctionResult(result, runtime: runtime)
     }
   }
 }

package/ios/Swift/Objects/ObjectDefinitionBuilder.swift

@@ -0,0 +1,25 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+public protocol AnyObjectDefinitionElement: AnyDefinition {}
+
+@resultBuilder
+public struct ObjectDefinitionBuilder {
+  public static func buildBlock(_ elements: AnyObjectDefinitionElement...) -> [AnyObjectDefinitionElement] {
+    return elements
+  }
+
+  /**
+   Default implementation without any constraints that just returns type-erased element.
+   */
+  public static func buildExpression<ElementType: AnyObjectDefinitionElement>(_ element: ElementType) -> AnyObjectDefinitionElement {
+    return element
+  }
+}
+
+extension SyncFunctionComponent: AnyObjectDefinitionElement {}
+
+extension AsyncFunctionComponent: AnyObjectDefinitionElement {}
+
+extension PropertyComponent: AnyObjectDefinitionElement {}
+
+extension ConstantsDefinition: AnyObjectDefinitionElement {}

package/ios/Swift/Objects/ObjectDefinitionComponents.swift

@@ -1,6 +1,12 @@
 /// This file implements definition components that are allowed in any object-based definition — `ObjectDefinition`.
 /// So far only constants and functions belong to plain object.
 
+// MARK: - Object
+
+public func Object(@ObjectDefinitionBuilder @_implicitSelfCapture _ body: () -> [AnyDefinition]) -> ObjectDefinition {
+  return ObjectDefinition(definitions: body())
+}
+
 // MARK: - Constants
 
 /**

package/ios/Swift/Views/ViewModuleWrapper.swift

@@ -109,15 +109,13 @@ public final class ViewModuleWrapper: RCTViewManager, DynamicModuleWrapperProtoc
     }
     let props = viewManager.propsDict()
 
-    for (key, value) in json {
-      if let prop = props[key] {
-        let value = Conversions.fromNSObject(value)
-
-        // TODO: @tsapeta: Figure out better way to rethrow errors from here.
-        // Adding `throws` keyword to the function results in different
-        // method signature in Objective-C. Maybe just call `RCTLogError`?
-        try? prop.set(value: value, onView: view)
-      }
+    for (key, prop) in props {
+      let newValue = json[key] as Any
+
+      // TODO: @tsapeta: Figure out better way to rethrow errors from here.
+      // Adding `throws` keyword to the function results in different
+      // method signature in Objective-C. Maybe just call `RCTLogError`?
+      try? prop.set(value: Conversions.fromNSObject(newValue), onView: view)
     }
     viewManager.callLifecycleMethods(withType: .didUpdateProps, forView: view)
   }

package/ios/Tests/FunctionSpec.swift

@@ -249,18 +249,42 @@ class FunctionSpec: ExpoSpec {
           Function("isArgNull") { (arg: Double?) -> Bool in
             return arg == nil
           }
+
+          Function("returnObjectDefinition") { (initial: Int) -> ObjectDefinition in
+            var foo = initial
+
+            return Object {
+              Function("increment") { () -> Int in
+                foo += 1
+                return foo
+              }
+            }
+          }
         })
       }
-      
+
       it("returns values") {
         expect(try runtime?.eval("expo.modules.TestModule.returnPi()").asDouble()) == Double.pi
         expect(try runtime?.eval("expo.modules.TestModule.returnNull()").isNull()) == true
       }
-      
+
       it("accepts optional arguments") {
         expect(try runtime?.eval("expo.modules.TestModule.isArgNull(3.14)").asBool()) == false
         expect(try runtime?.eval("expo.modules.TestModule.isArgNull(null)").asBool()) == true
       }
+
+      it("returns object made from definition") {
+        let initialValue = Int.random(in: 1..<100)
+        let object = try runtime?.eval("object = expo.modules.TestModule.returnObjectDefinition(\(initialValue))")
+
+        expect(object?.kind) == .object
+        expect(object?.getObject().hasProperty("increment")) == true
+
+        let result = try runtime?.eval("object.increment()")
+
+        expect(result?.kind) == .number
+        expect(result?.getInt()) == initialValue + 1
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "1.1.0",
+  "version": "1.2.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": "^3.0.0"
   },
-  "gitHead": "ba80e8181b79d06e00a245653727f4eaeb80420e"
+  "gitHead": "1815e2eaad8c753588c7b1eb74420174a28e01f4"
 }

package/src/NativeViewManagerAdapter.native.tsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import { NativeModules, requireNativeComponent } from 'react-native';
+import { NativeModules, requireNativeComponent, HostComponent } from 'react-native';
 
 // To make the transition from React Native's `requireNativeComponent` to Expo's
 // `requireNativeViewManager` as easy as possible, `requireNativeViewManager` is a drop-in
@@ -14,6 +14,27 @@ type NativeExpoComponentProps = {
   proxiedProperties: object;
 };
 
+/**
+ * A map that caches registered native components.
+ */
+const nativeComponentsCache = new Map<string, HostComponent<any>>();
+
+/**
+ * Requires a React Native component from cache if possible. This prevents
+ * "Tried to register two views with the same name" errors on fast refresh, but
+ * also when there are multiple versions of the same package with native component.
+ */
+function requireCachedNativeComponent<Props>(viewName: string): HostComponent<Props> {
+  const cachedNativeComponent = nativeComponentsCache.get(viewName);
+
+  if (!cachedNativeComponent) {
+    const nativeComponent = requireNativeComponent<Props>(viewName);
+    nativeComponentsCache.set(viewName, nativeComponent);
+    return nativeComponent;
+  }
+  return cachedNativeComponent;
+}
+
 /**
  * A drop-in replacement for `requireNativeComponent`.
  */
@@ -32,7 +53,7 @@ export function requireNativeViewManager<P>(viewName: string): React.ComponentTy
   // manager
   const reactNativeViewName = `ViewManagerAdapter_${viewName}`;
   const ReactNativeComponent =
-    requireNativeComponent<NativeExpoComponentProps>(reactNativeViewName);
+    requireCachedNativeComponent<NativeExpoComponentProps>(reactNativeViewName);
   const proxiedPropsNames = viewManagerConfig?.propsNames ?? [];
 
   // Define a component for universal-module authors to access their native view manager

package/src/SyntheticPlatformEmitter.ts

@@ -2,4 +2,4 @@
  * This emitter is used for sending synthetic native events to listeners
  * registered in the API layer with `NativeEventEmitter`.
  */
-export { default } from 'react-native/Libraries/EventEmitter/RCTDeviceEventEmitter';
+export { DeviceEventEmitter as default } from 'react-native';

package/build/SyntheticPlatformEmitter.web.d.ts

@@ -1,6 +0,0 @@
-/**
- * This emitter is used for sending synthetic native events to listeners
- * registered in the API layer with `NativeEventEmitter`.
- */
-export { default } from 'react-native-web/dist/vendor/react-native/NativeEventEmitter/RCTDeviceEventEmitter';
-//# sourceMappingURL=SyntheticPlatformEmitter.web.d.ts.map

package/build/SyntheticPlatformEmitter.web.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SyntheticPlatformEmitter.web.d.ts","sourceRoot":"","sources":["../src/SyntheticPlatformEmitter.web.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,oFAAoF,CAAC"}

package/build/SyntheticPlatformEmitter.web.js

@@ -1,6 +0,0 @@
-/**
- * This emitter is used for sending synthetic native events to listeners
- * registered in the API layer with `NativeEventEmitter`.
- */
-export { default } from 'react-native-web/dist/vendor/react-native/NativeEventEmitter/RCTDeviceEventEmitter';
-//# sourceMappingURL=SyntheticPlatformEmitter.web.js.map

package/build/SyntheticPlatformEmitter.web.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SyntheticPlatformEmitter.web.js","sourceRoot":"","sources":["../src/SyntheticPlatformEmitter.web.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,oFAAoF,CAAC","sourcesContent":["/**\n * This emitter is used for sending synthetic native events to listeners\n * registered in the API layer with `NativeEventEmitter`.\n */\nexport { default } from 'react-native-web/dist/vendor/react-native/NativeEventEmitter/RCTDeviceEventEmitter';\n"]}

package/src/SyntheticPlatformEmitter.web.ts

@@ -1,5 +0,0 @@
-/**
- * This emitter is used for sending synthetic native events to listeners
- * registered in the API layer with `NativeEventEmitter`.
- */
-export { default } from 'react-native-web/dist/vendor/react-native/NativeEventEmitter/RCTDeviceEventEmitter';