expo-modules-core 0.8.0 → 0.9.2

package/android/src/main/java/expo/modules/kotlin/views/ViewManagerDefinitionBuilder.kt

@@ -1,4 +1,5 @@
 @file:OptIn(ExperimentalStdlibApi::class)
+@file:Suppress("FunctionName")
 
 package expo.modules.kotlin.views
 
@@ -12,12 +13,16 @@ import kotlin.reflect.typeOf
 class ViewManagerDefinitionBuilder {
   @PublishedApi
   internal var viewFactory: ((Context) -> View)? = null
+
   @PublishedApi
   internal var viewType: Class<out View>? = null
+
   @PublishedApi
   internal var props = mutableMapOf<String, AnyViewProp>()
+
   @PublishedApi
   internal var onViewDestroys: ((View) -> Unit)? = null
+
   @PublishedApi
   internal var viewGroupDefinition: ViewGroupDefinition? = null
   private var callbacksDefinition: CallbacksDefinition? = null
@@ -32,25 +37,46 @@ class ViewManagerDefinitionBuilder {
       viewGroupDefinition
     )
 
+  @Deprecated(
+    message = "The 'view' component was renamed to 'View'.",
+    replaceWith = ReplaceWith("View(body)")
+  )
+  inline fun <reified ViewType : View> view(noinline body: (Context) -> ViewType) = View(body)
+
   /**
    * Defines the factory creating a native view when the module is used as a view.
    */
-  inline fun <reified ViewType : View> view(noinline body: (Context) -> ViewType) {
+  inline fun <reified ViewType : View> View(noinline body: (Context) -> ViewType) {
     viewType = ViewType::class.java
     viewFactory = body
   }
 
+  @Deprecated(
+    message = "The 'onViewDestroys' component was renamed to 'OnViewDestroys'.",
+    replaceWith = ReplaceWith("OnViewDestroys(body)")
+  )
+  inline fun <reified ViewType : View> onViewDestroys(noinline body: (view: ViewType) -> Unit) = OnViewDestroys(body)
+
   /**
    * Creates view's lifecycle listener that is called right after the view isn't longer used by React Native.
    */
-  inline fun <reified ViewType : View> onViewDestroys(noinline body: (view: ViewType) -> Unit) {
+  inline fun <reified ViewType : View> OnViewDestroys(noinline body: (view: ViewType) -> Unit) {
     onViewDestroys = { body(it as ViewType) }
   }
 
+  @Deprecated(
+    message = "The 'prop' component was renamed to 'Prop'.",
+    replaceWith = ReplaceWith("Prop(body)")
+  )
+  inline fun <reified ViewType : View, reified PropType> prop(
+    name: String,
+    noinline body: (view: ViewType, prop: PropType) -> Unit
+  ) = Prop(name, body)
+
   /**
    * Creates a view prop that defines its name and setter.
    */
-  inline fun <reified ViewType : View, reified PropType> prop(
+  inline fun <reified ViewType : View, reified PropType> Prop(
     name: String,
     noinline body: (view: ViewType, prop: PropType) -> Unit
   ) {
@@ -61,17 +87,29 @@ class ViewManagerDefinitionBuilder {
     )
   }
 
+  @Deprecated(
+    message = "The 'events' component was renamed to 'Events'.",
+    replaceWith = ReplaceWith("Events(callbacks)")
+  )
+  fun events(vararg callbacks: String) = Events(*callbacks)
+
   /**
    * Defines prop names that should be treated as callbacks.
    */
-  fun events(vararg callbacks: String) {
+  fun Events(vararg callbacks: String) {
     callbacksDefinition = CallbacksDefinition(callbacks)
   }
 
+  @Deprecated(
+    message = "The 'groupView' component was renamed to 'GroupView'.",
+    replaceWith = ReplaceWith("GroupView(callbacks)")
+  )
+  inline fun groupView(body: ViewGroupDefinitionBuilder.() -> Unit) = GroupView(body)
+
   /**
    * Creates the group view definition that scopes group view-related definitions.
    */
-  inline fun groupView(body: ViewGroupDefinitionBuilder.() -> Unit) {
+  inline fun GroupView(body: ViewGroupDefinitionBuilder.() -> Unit) {
     require(viewGroupDefinition == null) { "The viewManager definition may have exported only one groupView definition." }
 
     val groupViewDefinitionBuilder = ViewGroupDefinitionBuilder()

package/ios/NativeModulesProxy/EXNativeModulesProxy.mm

@@ -278,6 +278,9 @@ RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNa
     // their base view managers that provides common props such as `proxiedProperties`.
     // Otherwise, React Native may treat these props as invalid in subclassing views.
     [additionalModuleClasses addObject:[EXViewManagerAdapter class]];
+    // Also, we have to register component data for the View Adapter.
+    // Otherwise, it won't be recognized by the UIManager.
+    [self registerLegacyComponentData:[EXViewManagerAdapter class] inBridge:bridge];
 
     // Some modules might need access to the bridge.
     for (id module in [_exModuleRegistry getAllInternalModules]) {

package/ios/Swift/AppContext.swift

@@ -18,7 +18,7 @@ public final class AppContext {
   /**
    The legacy module registry with modules written in the old-fashioned way.
    */
-  public private(set) var legacyModuleRegistry: EXModuleRegistry?
+  public private(set) weak var legacyModuleRegistry: EXModuleRegistry?
 
   /**
    React bridge of the context's app.
@@ -104,13 +104,6 @@ public final class AppContext {
     return legacyModule(implementing: EXEventEmitterService.self)
   }
 
-  /**
-   Provides access to the logger from legacy module registry.
-   */
-  public var logger: EXLogManager? {
-    return legacyModuleRegistry?.getSingletonModule(forName: EXLogManager.name()) as? EXLogManager
-  }
-
   /**
    Starts listening to `UIApplication` notifications.
    */

package/ios/Swift/Arguments/AnyArgumentType.swift

@@ -4,7 +4,7 @@
  A protocol whose intention is to wrap function's argument type
  to keep its real signature and not type-erase it by the compiler.
  */
-internal protocol AnyArgumentType: CustomStringConvertible {
+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`).

package/ios/Swift/Functions/AnyFunction.swift

@@ -14,6 +14,11 @@ public protocol AnyFunction: AnyDefinition {
    */
   var takesPromise: Bool { get }
 
+  /**
+   An array of argument types that the function takes. If the last type is `Promise`, it's not included.
+   */
+  var argumentTypes: [AnyArgumentType] { get }
+
   /**
    A number of arguments the function takes. If the last argument is of type `Promise`, it is not counted.
    */

package/ios/Swift/Functions/AsyncFunctionComponent.swift

@@ -0,0 +1,182 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Represents a function that can only be called asynchronously, thus its JavaScript equivalent returns a Promise.
+
+ - ToDo: Move some asynchronous logic from `ConcreteFunction` (like `call(args:promise:)`) to this class and drop the `isAsync` property.
+ */
+internal final class AsyncFunctionComponent<Args, ReturnType>: ConcreteFunction<Args, ReturnType> {
+  override init(
+    _ name: String,
+    argTypes: [AnyArgumentType],
+    _ closure: @escaping ConcreteFunction<Args, ReturnType>.ClosureType
+  ) {
+    super.init(name, argTypes: argTypes, closure)
+    self.isAsync = true
+  }
+}
+
+/**
+ Asynchronous function without arguments.
+ */
+public func AsyncFunction<R>(
+  _ name: String,
+  _ closure: @escaping () throws -> R
+) -> AnyFunction {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with one argument.
+ */
+public func AsyncFunction<R, A0: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0) throws -> R
+) -> AnyFunction {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [ArgumentType(A0.self)],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with two arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1) throws -> R
+) -> AnyFunction {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with three arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2) throws -> R
+) -> AnyFunction {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with four arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3) throws -> R
+) -> AnyFunction {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with five arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3, A4) throws -> R
+) -> AnyFunction {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with six arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3, A4, A5) throws -> R
+) -> AnyFunction {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self)
+    ],
+    closure
+  )
+}
+
+/**
+ 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,
+  _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6) throws -> R
+) -> AnyFunction {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self),
+      ArgumentType(A6.self)
+    ],
+    closure
+  )
+}
+
+/**
+ 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,
+  _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6, A7) throws -> R
+) -> AnyFunction {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self),
+      ArgumentType(A6.self),
+      ArgumentType(A7.self)
+    ],
+    closure
+  )
+}

package/ios/Swift/Functions/ConcreteFunction.swift

@@ -5,12 +5,10 @@ public class ConcreteFunction<Args, ReturnType>: AnyFunction {
 
   public let name: String
 
-  public var takesPromise: Bool {
-    return argTypes.last is PromiseArgumentType
-  }
+  public var takesPromise: Bool
 
   public var argumentsCount: Int {
-    return argTypes.count - (takesPromise ? 1 : 0)
+    return argumentTypes.count
   }
 
   public var queue: DispatchQueue?
@@ -19,7 +17,7 @@ public class ConcreteFunction<Args, ReturnType>: AnyFunction {
 
   let closure: ClosureType
 
-  let argTypes: [AnyArgumentType]
+  public let argumentTypes: [AnyArgumentType]
 
   init(
     _ name: String,
@@ -27,28 +25,33 @@ public class ConcreteFunction<Args, ReturnType>: AnyFunction {
     _ closure: @escaping ClosureType
   ) {
     self.name = name
-    self.argTypes = argTypes
+    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) {
-    let takesPromise = self.takesPromise
+    // Add promise to the array of arguments if necessary.
+    let arguments = takesPromise ? args + [promise] : args
     let returnedValue: ReturnType?
 
     do {
-      var finalArgs = try castArguments(args)
-
-      if takesPromise {
-        finalArgs.append(promise)
-      }
-
-      let tuple = try Conversions.toTuple(finalArgs) as! Args
-      returnedValue = try closure(tuple)
+      let argumentsTuple = try Conversions.toTuple(arguments) as! Args
+      returnedValue = try closure(argumentsTuple)
     } catch let error as CodedError {
       promise.reject(FunctionCallException(name).causedBy(error))
       return
@@ -61,28 +64,24 @@ public class ConcreteFunction<Args, ReturnType>: AnyFunction {
     }
   }
 
+  /**
+   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 {
-      var result: Any?
-      let semaphore = DispatchSemaphore(value: 0)
-
-      let promise = Promise {
-        result = $0
-        semaphore.signal()
-      } rejecter: { _ in
-        semaphore.signal()
-      }
-      call(args: args, promise: promise)
-      semaphore.wait()
-      return result as Any
-    } else {
-      do {
-        let finalArgs = try castArguments(args)
-        let tuple = try Conversions.toTuple(finalArgs) as! Args
-        return try closure(tuple)
-      } catch let error {
-        return error
-      }
+      // 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
     }
   }
 
@@ -95,38 +94,6 @@ public class ConcreteFunction<Args, ReturnType>: AnyFunction {
     self.isAsync = false
     return self
   }
-
-  private func argumentType(atIndex index: Int) -> AnyArgumentType? {
-    return (0..<argTypes.count).contains(index) ? argTypes[index] : nil
-  }
-
-  private func castArguments(_ args: [Any]) throws -> [Any] {
-    if args.count != argumentsCount {
-      throw InvalidArgsNumberException((received: args.count, expected: argumentsCount))
-    }
-    return try args.enumerated().map { index, arg in
-      let expectedType = argumentType(atIndex: index)
-
-      do {
-        // It's safe to unwrap since the arguments count matches.
-        return try expectedType!.cast(arg)
-      } catch {
-        throw ArgumentCastException((index: index, type: expectedType!)).causedBy(error)
-      }
-    }
-  }
-}
-
-internal class InvalidArgsNumberException: GenericException<(received: Int, expected: Int)> {
-  override var reason: String {
-    "Received \(param.received) arguments, but \(param.expected) was expected"
-  }
-}
-
-internal class ArgumentCastException: GenericException<(index: Int, type: AnyArgumentType)> {
-  override var reason: String {
-    "Argument at index '\(param.index)' couldn't be cast to type \(param.type.description)"
-  }
 }
 
 internal class FunctionCallException: GenericException<String> {

package/ios/Swift/Functions/SyncFunctionComponent.swift

@@ -0,0 +1,181 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Represents a function that can only be called synchronously.
+ - ToDo: Move some synchronous logic from `ConcreteFunction` (like `call(args:)`) to this class and drop the `isAsync` property.
+ */
+internal final class SyncFunctionComponent<Args, ReturnType>: ConcreteFunction<Args, ReturnType> {
+  override init(
+    _ name: String,
+    argTypes: [AnyArgumentType],
+    _ closure: @escaping ConcreteFunction<Args, ReturnType>.ClosureType
+  ) {
+    super.init(name, argTypes: argTypes, closure)
+    self.isAsync = false
+  }
+}
+
+/**
+ Synchronous function without arguments.
+ */
+public func Function<R>(
+  _ name: String,
+  _ closure: @escaping () throws -> R
+) -> AnyFunction {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [],
+    closure
+  )
+}
+
+/**
+ Synchronous function with one argument.
+ */
+public func Function<R, A0: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0) throws -> R
+) -> AnyFunction {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [ArgumentType(A0.self)],
+    closure
+  )
+}
+
+/**
+ Synchronous function with two arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1) throws -> R
+) -> AnyFunction {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
+    closure
+  )
+}
+
+/**
+ Synchronous function with three arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2) throws -> R
+) -> AnyFunction {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with four arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3) throws -> R
+) -> AnyFunction {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with five arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3, A4) throws -> R
+) -> AnyFunction {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with six arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3, A4, A5) throws -> R
+) -> AnyFunction {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with seven arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6) throws -> R
+) -> AnyFunction {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self),
+      ArgumentType(A6.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with eight arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument, A7: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6, A7) throws -> R
+) -> AnyFunction {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self),
+      ArgumentType(A6.self),
+      ArgumentType(A7.self)
+    ],
+    closure
+  )
+}