expo-modules-core 0.9.2 → 0.11.1

package/ios/Swift/JavaScriptUtils.swift

@@ -1,97 +1,72 @@
 // Copyright 2022-present 650 Industries. All rights reserved.
 
-// FIXME: Calling module's functions needs solid refactoring to not reference the module holder.
-// Instead, it should be possible to directly call the function instance from here. (added by @tsapeta)
-
-/**
- Creates a block that is executed when the module's async function is called.
- */
-internal func createAsyncFunctionBlock(holder: ModuleHolder, name functionName: String) -> JSAsyncFunctionBlock {
-  let moduleName = holder.name
-  return { [weak holder, moduleName] args, resolve, reject in
-    guard let holder = holder else {
-      let exception = ModuleUnavailableException(moduleName)
-      reject(exception.code, exception.description, exception)
-      return
-    }
-    holder.call(function: functionName, args: args) { result, error in
-      if let error = error {
-        reject(error.code, error.description, error)
-      } else {
-        resolve(result)
-      }
-    }
-  }
-}
-
-/**
- Creates a block that is executed when the module's sync function is called.
- */
-internal func createSyncFunctionBlock(holder: ModuleHolder, name functionName: String) -> JSSyncFunctionBlock {
-  return { [weak holder] args in
-    guard let holder = holder else {
-      return nil
-    }
-    return holder.callSync(function: functionName, args: args)
-  }
-}
-
 // MARK: - Arguments
 
 /**
- Tries to cast given argument to the type that is wrapped by the argument type.
+ Tries to cast a given value to the type that is wrapped by the dynamic type.
  - Parameters:
-  - argument: A value to be cast. If it's a ``JavaScriptValue``, it's first unpacked to the raw value.
-  - argumentType: Something that implements ``AnyArgumentType`` and knows how to cast the argument.
- - Returns: A new value converted according to the argument type.
- - Throws: Rethrows various exceptions that could be thrown by the argument type wrappers.
+  - value: A value to be cast. If it's a ``JavaScriptValue``, it's first unpacked to the raw value.
+  - type: Something that implements ``AnyDynamicType`` and knows how to cast the argument.
+ - Returns: A new value converted according to the dynamic type.
+ - Throws: Rethrows various exceptions that could be thrown by the dynamic types.
  */
-internal func castArgument(_ argument: Any, toType argumentType: AnyArgumentType) throws -> Any {
+internal func cast(_ value: Any, toType type: AnyDynamicType) throws -> Any {
   // TODO: Accept JavaScriptValue and JavaScriptObject as argument types.
-  if let argument = argument as? JavaScriptValue {
-    return try argumentType.cast(argument.getRaw())
+  if !(type is DynamicTypedArrayType), let value = value as? JavaScriptValue {
+    return try type.cast(value.getRaw())
   }
-  return try argumentType.cast(argument)
+  return try type.cast(value)
 }
 
 /**
- Same as ``castArgument(_:argumentType:)`` but for an array of arguments.
+ Tries to cast the given arguments to the types expected by the function.
  - Parameters:
    - arguments: An array of arguments to be cast.
-   - argumentTypes: An array of argument types in the same order as the array of arguments.
+   - function: A function for which to cast the arguments.
  - Returns: An array of arguments after casting. Its size is the same as the input arrays.
- - Throws: ``InvalidArgsNumberException`` when the sizes of arrays passed as parameters are not equal.
-   Rethrows exceptions thrown by ``castArgument(_:argumentType:)``.
+ - Throws: `InvalidArgsNumberException` when the number of arguments is not equal to the actual number
+ of function's arguments (without an owner and promise). Rethrows exceptions thrown by `cast(_:toType:)`.
  */
-internal func castArguments(_ arguments: [Any], toTypes argumentTypes: [AnyArgumentType]) throws -> [Any] {
-  if arguments.count != argumentTypes.count {
-    throw InvalidArgsNumberException((received: arguments.count, expected: argumentTypes.count))
+internal func cast(arguments: [Any], forFunction function: AnyFunction) throws -> [Any] {
+  if arguments.count != function.argumentsCount {
+    throw InvalidArgsNumberException((received: arguments.count, expected: function.argumentsCount))
   }
+  let argumentTypeOffset = function.takesOwner ? 1 : 0
   return try arguments.enumerated().map { index, argument in
-    let argumentType = argumentTypes[index]
+    let argumentType = function.dynamicArgumentTypes[index + argumentTypeOffset]
 
     do {
-      return try castArgument(argument, toType: argumentType)
+      return try cast(argument, toType: argumentType)
     } catch {
       throw ArgumentCastException((index: index, type: argumentType)).causedBy(error)
     }
   }
 }
 
+/**
+ Prepends the owner to the array of arguments if the given function can take it.
+ */
+internal func concat(arguments: [Any], withOwner owner: AnyObject?, forFunction function: AnyFunction) -> [Any] {
+  if function.takesOwner, let owner = try? function.dynamicArgumentTypes.first?.cast(owner) {
+    return [owner] + arguments
+  }
+  return arguments
+}
+
+// MARK: - Exceptions
+
 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)> {
+internal class ArgumentCastException: GenericException<(index: Int, type: AnyDynamicType)> {
   override var reason: String {
     "Argument at index '\(param.index)' couldn't be cast to type \(param.type.description)"
   }
 }
 
-// MARK: - Exceptions
-
 private class ModuleUnavailableException: GenericException<String> {
   override var reason: String {
     "Module '\(param)' is no longer available"

package/ios/Swift/Logging/LogHandlers.swift

@@ -0,0 +1,39 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import os.log
+
+/**
+ The protocol that needs to be implemented by log handlers.
+ */
+internal protocol LogHandler {
+  init(category: String)
+
+  func log(type: LogType, _ message: String)
+}
+
+/**
+ The log handler that uses the new `os.Logger` API.
+ */
+@available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
+internal class OSLogHandler: LogHandler {
+  private let osLogger: os.Logger
+
+  required init(category: String) {
+    osLogger = os.Logger(subsystem: "dev.expo.modules", category: category)
+  }
+
+  func log(type: LogType, _ message: String) {
+    osLogger.log(level: type.toOSLogType(), "\(message)")
+  }
+}
+
+/**
+ Simple log handler that forwards all logs to `print` function.
+ */
+internal class PrintLogHandler: LogHandler {
+  required init(category: String) {}
+
+  func log(type: LogType, _ message: String) {
+    print(message)
+  }
+}

package/ios/Swift/Logging/LogType.swift

@@ -0,0 +1,62 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import os.log
+
+/**
+ An enum with available log types.
+ */
+public enum LogType: Int {
+  case trace = 0
+  case timer = 1
+  case stacktrace = 2
+  case debug = 3
+  case info = 4
+  case warn = 5
+  case error = 6
+  case fatal = 7
+
+  /**
+   The string that is used to prefix the messages of this log type.
+   Logs in Xcode and Console apps are always with the white text,
+   so we use colored circle emojis to distinguish different types of logs.
+   */
+  var prefix: String {
+    switch self {
+    case .trace:
+      return "⚪️"
+    case .timer:
+      return "🟤"
+    case .stacktrace:
+      return "🟣"
+    case .debug:
+      return "🔵"
+    case .info:
+      return "🟢"
+    case .warn:
+      return "🟡"
+    case .error:
+      return "🟠"
+    case .fatal:
+      return "🔴"
+    }
+  }
+
+  /**
+   Maps the log types to the log types used by the `os.log` logger.
+   */
+  @available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
+  func toOSLogType() -> OSLogType {
+    switch self {
+    case .trace, .timer, .stacktrace, .debug:
+      return .debug
+    case .info:
+      return .info
+    case .warn:
+      return .default
+    case .error:
+      return .error
+    case .fatal:
+      return .fault
+    }
+  }
+}

package/ios/Swift/Logging/Logger.swift

@@ -0,0 +1,201 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+import Dispatch
+
+public let log = Logger(category: "expo")
+
+public class Logger {
+  #if DEBUG || EXPO_CONFIGURATION_DEBUG
+  private var minLevel: LogType = .trace
+  #else
+  private var minLevel: LogType = .info
+  #endif
+
+  private let category: String
+
+  private var handlers: [LogHandler] = []
+
+  init(category: String = "main") {
+    self.category = category
+
+    if #available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *) {
+      addHandler(withType: OSLogHandler.self)
+    } else {
+      addHandler(withType: PrintLogHandler.self)
+    }
+  }
+
+  internal func addHandler<LogHandlerType: LogHandler>(_ handler: LogHandlerType) {
+    handlers.append(handler)
+  }
+
+  internal func addHandler<LogHandlerType: LogHandler>(withType: LogHandlerType.Type) {
+    addHandler(LogHandlerType(category: category))
+  }
+
+  // MARK: - Public logging functions
+
+  /**
+   The most verbose log level that captures all the details about the behavior of the implementation.
+   It is mostly diagnostic and is more granular and finer than `debug` log level.
+   These logs should not be committed to the repository and are ignored in the release builds.
+   */
+  public func trace(_ items: Any...) {
+    log(type: .trace, items)
+  }
+
+  /**
+   Used to log diagnostically helpful information. As opposed to `trace`,
+   it is acceptable to commit these logs to the repository. Ignored in the release builds.
+   */
+  public func debug(_ items: Any...) {
+    log(type: .debug, items)
+  }
+
+  /**
+   For information that should be logged under normal conditions such as successful initialization
+   and notable events that are not considered an error but might be useful for debugging purposes in the release builds.
+   */
+  public func info(_ items: Any...) {
+    log(type: .info, items)
+  }
+
+  /**
+   Used to log an unwanted state that has not much impact on the process so it can be continued, but could potentially become an error.
+   */
+  public func warn(_ items: Any...) {
+    log(type: .warn, items)
+  }
+
+  /**
+   Logs unwanted state that has an impact on the currently running process, but the entire app can continue to run.
+   */
+  public func error(_ items: Any...) {
+    log(type: .error, items)
+  }
+
+  /**
+   Logs critical error due to which the entire app cannot continue to run.
+   */
+  public func fatal(_ items: Any...) {
+    log(type: .fatal, items)
+  }
+
+  /**
+   Logs the stack of symbols on the current thread.
+   */
+  public func stacktrace(type: LogType = .stacktrace, file: String = #fileID, line: UInt = #line) {
+    guard type.rawValue >= minLevel.rawValue else {
+      return
+    }
+    let queueName = OperationQueue.current?.underlyingQueue?.label ?? "<unknown>"
+
+    // Get the call stack symbols without the first symbol as it points right here.
+    let symbols = Thread.callStackSymbols.dropFirst()
+
+    log(type: type, "The stacktrace from '\(file):\(line)' on queue '\(queueName)':")
+
+    symbols.forEach { symbol in
+      let formattedSymbol = reformatStackSymbol(symbol)
+      log(type: type, "≫ \(formattedSymbol)")
+    }
+  }
+
+  /**
+   Allows the logger instance to be called as a function. The same as `logger.debug(...)`.
+   */
+  public func callAsFunction(_ items: Any...) {
+    log(type: .debug, items)
+  }
+
+  // MARK: - Timers
+
+  /**
+   Stores the timers created by `timeStart` function.
+   */
+  private var timers: [String: DispatchTime] = [:]
+
+  /**
+   Starts the timer to measure how much time the following operations take.
+   */
+  public func timeStart(_ id: String) {
+    guard LogType.timer.rawValue >= minLevel.rawValue else {
+      return
+    }
+    log(type: .timer, "Starting timer '\(id)'")
+    timers[id] = DispatchTime.now()
+  }
+
+  /**
+   Stops the timer and logs how much time elapsed since it started.
+   */
+  public func timeEnd(_ id: String) {
+    guard LogType.timer.rawValue >= minLevel.rawValue else {
+      return
+    }
+    guard let startTime = timers[id] else {
+      log(type: .timer, "Timer '\(id)' has not been started!")
+      return
+    }
+    let endTime = DispatchTime.now()
+    let diff = Double(endTime.uptimeNanoseconds - startTime.uptimeNanoseconds) / 1_000_000
+    log(type: .timer, "Timer '\(id)' has finished in: \(diff) seconds")
+    timers.removeValue(forKey: id)
+  }
+
+  /**
+   Measures how much time it takes to run given closure. Returns the same value as the closure returned.
+   */
+  public func time<ReturnType>(_ id: String, _ closure: () -> ReturnType) -> ReturnType {
+    timeStart(id)
+    let result = closure()
+    timeEnd(id)
+    return result
+  }
+
+  // MARK: - Changing the category
+
+  public func category(_ category: String) -> Logger {
+    return Logger(category: category)
+  }
+
+  // MARK: - Private logging functions
+
+  private func log(type: LogType = .trace, _ items: [Any]) {
+    guard type.rawValue >= minLevel.rawValue else {
+      return
+    }
+    let messages = items
+      .map { describe(value: $0) }
+      .joined(separator: " ")
+      .split(whereSeparator: \.isNewline)
+      .map { "\(type.prefix) \($0)" }
+
+    handlers.forEach { handler in
+      messages.forEach { message in
+        handler.log(type: type, message)
+      }
+    }
+  }
+
+  private func log(type: LogType = .trace, _ items: Any...) {
+    log(type: type, items)
+  }
+}
+
+fileprivate func reformatStackSymbol(_ symbol: String) -> String {
+  return symbol.replacingOccurrences(of: #"^\d+\s+"#, with: "", options: .regularExpression)
+}
+
+fileprivate func describe(value: Any) -> String {
+  if let value = value as? String {
+    return value
+  }
+  if let value = value as? CustomDebugStringConvertible {
+    return value.debugDescription
+  }
+  if let value = value as? CustomStringConvertible {
+    return value.description
+  }
+  return String(describing: value)
+}

package/ios/Swift/ModuleHolder.swift

@@ -56,54 +56,33 @@ public final class ModuleHolder {
    Merges all `constants` definitions into one dictionary.
    */
   func getConstants() -> [String: Any?] {
-    return definition.constants.reduce(into: [String: Any?]()) { dict, definition in
-      dict.merge(definition.body()) { $1 }
-    }
+    return definition.getConstants()
   }
 
   // MARK: Calling functions
 
-  func call(function functionName: String, args: [Any], promise: Promise) {
-    do {
-      guard let function = definition.functions[functionName] else {
-        throw FunctionNotFoundException((functionName: functionName, moduleName: self.name))
-      }
-      let queue = function.queue ?? DispatchQueue.global(qos: .default)
-
-      // Given arguments can be:
-      // - Swift primitives when invoked through the bridge and in unit tests
-      // - `JavaScriptValue`s when the function is called through the JSI
-      // The latter need to be unpacked to Swift primitives on the JS thread,
-      // so we do the casting before the function call is scheduled on the queue.
-      let arguments = try castArguments(args, toTypes: function.argumentTypes)
-
-      queue.async {
-        function.call(args: arguments, promise: promise)
-      }
-    } catch let error as CodedError {
-      promise.reject(error)
-    } catch {
-      promise.reject(UnexpectedException(error))
-    }
-  }
-
-  func call(function functionName: String, args: [Any], _ callback: @escaping (Any?, CodedError?) -> Void = { _, _ in }) {
-    let promise = Promise {
-      callback($0, nil)
-    } rejecter: {
-      callback(nil, $0)
+  func call(function functionName: String, args: [Any], _ callback: @escaping (FunctionCallResult) -> () = { _ in }) {
+    guard let function = definition.functions[functionName] else {
+      callback(.failure(FunctionNotFoundException((functionName: functionName, moduleName: self.name))))
+      return
     }
-    call(function: functionName, args: args, promise: promise)
+    function.call(by: self, withArguments: args, callback: callback)
   }
 
   @discardableResult
   func callSync(function functionName: String, args: [Any]) -> Any? {
-    guard let function = definition.functions[functionName] else {
+    guard let function = definition.functions[functionName] as? AnySyncFunctionComponent else {
       return nil
     }
     do {
-      let arguments = try castArguments(args, toTypes: function.argumentTypes)
-      return function.callSync(args: arguments)
+      let arguments = try cast(arguments: args, forFunction: function)
+      let result = try function.call(by: self, withArguments: arguments)
+
+      if let result = result as? SharedObject {
+        let jsObject = SharedObjectRegistry.ensureSharedJavaScriptObject(runtime: appContext!.runtime!, nativeObject: result)
+        return jsObject
+      }
+      return result
     } catch {
       return error
     }
@@ -119,24 +98,10 @@ public final class ModuleHolder {
    */
   private func createJavaScriptModuleObject() -> JavaScriptObject? {
     // It might be impossible to create any object at the moment (e.g. remote debugging, app context destroyed)
-    guard let object = appContext?.runtime?.createObject() else {
+    guard let runtime = appContext?.runtime else {
       return nil
     }
-
-    // Fill in with constants
-    for (key, value) in getConstants() {
-      object.setProperty(key, value: value)
-    }
-
-    // Fill in with functions
-    for (_, fn) in definition.functions {
-      if fn.isAsync {
-        object.setAsyncFunction(fn.name, argsCount: fn.argumentsCount, block: createAsyncFunctionBlock(holder: self, name: fn.name))
-      } else {
-        object.setSyncFunction(fn.name, argsCount: fn.argumentsCount, block: createSyncFunctionBlock(holder: self, name: fn.name))
-      }
-    }
-    return object
+    return definition.build(inRuntime: runtime)
   }
 
   // MARK: Listening to native events
@@ -166,9 +131,9 @@ public final class ModuleHolder {
    */
   func modifyListenersCount(_ count: Int) {
     if count > 0 && listenersCount == 0 {
-      _ = definition.functions["startObserving"]?.callSync(args: [])
+      definition.functions["startObserving"]?.call(withArguments: [])
     } else if count < 0 && listenersCount + count <= 0 {
-      _ = definition.functions["stopObserving"]?.callSync(args: [])
+      definition.functions["stopObserving"]?.call(withArguments: [])
     }
     listenersCount = max(0, listenersCount + count)
   }

package/ios/Swift/ModuleRegistry.swift

@@ -13,6 +13,7 @@ public final class ModuleRegistry: Sequence {
    Registers an instance of module holder.
    */
   internal func register(holder: ModuleHolder) {
+    log.info("Registering module '\(holder.name)'")
     registry[holder.name] = holder
   }
 
@@ -47,7 +48,10 @@ public final class ModuleRegistry: Sequence {
   }
 
   public func unregister(moduleName: String) {
-    registry[moduleName] = nil
+    if registry[moduleName] != nil {
+      log.info("Unregistering module '\(moduleName)'")
+      registry[moduleName] = nil
+    }
   }
 
   public func has(moduleWithName moduleName: String) -> Bool {
@@ -71,12 +75,14 @@ public final class ModuleRegistry: Sequence {
   }
 
   internal func post(event: EventName) {
+    log.info("Posting '\(event)' event to registered modules")
     forEach { holder in
       holder.post(event: event)
     }
   }
 
   internal func post<PayloadType>(event: EventName, payload: PayloadType? = nil) {
+    log.info("Posting '\(event)' event to registered modules")
     forEach { holder in
       holder.post(event: event, payload: payload)
     }

package/ios/Swift/Modules/AnyModule.swift

@@ -16,8 +16,8 @@ public protocol AnyModule: AnyObject, AnyArgument {
 
    ```
    public func definition() -> ModuleDefinition {
-     name("MyModule")
-     function("myFunction") { (a: String, b: String) in
+     Name("MyModule")
+     AsyncFunction("myFunction") { (a: String, b: String) in
        "\(a) \(b)"
      }
    }
@@ -37,7 +37,7 @@ public protocol AnyModule: AnyObject, AnyArgument {
    just specify an argument of type `Promise` as the last one and use its `resolve` or `reject` functions.
 
    ```
-   function("myFunction") { (promise: Promise) in
+   AsyncFunction("myFunction") { (promise: Promise) in
      DispatchQueue.main.async {
        promise.resolve("return value obtained in async callback")
      }

package/ios/Swift/ModulesProvider.swift

@@ -24,6 +24,8 @@ public protocol ModulesProviderProtocol {
  */
 @objc
 open class ModulesProvider: NSObject, ModulesProviderProtocol {
+  public override required init() {}
+
   open func getModuleClasses() -> [AnyModule.Type] {
     return []
   }

package/ios/Swift/Objects/JavaScriptObjectBuilder.swift

@@ -0,0 +1,37 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ A type that can decorate a `JavaScriptObject` with some properties.
+ */
+internal protocol JavaScriptObjectDecorator {
+  /**
+   Decorates an existing `JavaScriptObject`.
+   */
+  func decorate(object: JavaScriptObject, inRuntime runtime: JavaScriptRuntime)
+}
+
+/**
+ A type that can build and decorate a `JavaScriptObject` based on its attributes.
+ */
+internal protocol JavaScriptObjectBuilder: JavaScriptObjectDecorator {
+  /**
+   Creates a decorated `JavaScriptObject` in the given runtime.
+   */
+  func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject
+}
+
+/**
+ Provides the default behavior of `JavaScriptObjectBuilder`.
+ The `build(inRuntime:)` creates a plain object and uses `decorate(object:)` for decoration.
+ */
+extension JavaScriptObjectBuilder {
+  func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
+    let object = runtime.createObject()
+    decorate(object: object, inRuntime: runtime)
+    return object
+  }
+
+  func decorate(object: JavaScriptObject, inRuntime runtime: JavaScriptRuntime) {
+    // no-op by default
+  }
+}