expo-modules-core 1.11.13 → 1.12.1

package/ios/Core/Functions/SyncFunctionDefinition.swift

@@ -0,0 +1,108 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Type-erased protocol for synchronous functions.
+ */
+internal protocol AnySyncFunctionDefinition: AnyFunctionDefinition {
+  /**
+   Calls the function synchronously with given arguments.
+   - Parameters:
+     - owner: An object that calls this function. If the `takesOwner` property is true
+       and type of the first argument matches the owner type, it's being passed as the argument.
+     - args: An array of arguments to pass to the function. The arguments must be of the same type as in the underlying closure.
+     - appContext: An app context where the function is executed.
+   - Returns: A value returned by the called function when succeeded or an error when it failed.
+   */
+  func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext) throws -> Any
+}
+
+/**
+ Represents a function that can only be called synchronously.
+ */
+public final class SyncFunctionDefinition<Args, FirstArgType, ReturnType>: AnySyncFunctionDefinition {
+  typealias ClosureType = (Args) throws -> ReturnType
+
+  /**
+   The underlying closure to run when the function is called.
+   */
+  let body: ClosureType
+
+  init(
+    _ name: String,
+    firstArgType: FirstArgType.Type,
+    dynamicArgumentTypes: [AnyDynamicType],
+    _ body: @escaping ClosureType
+  ) {
+    self.name = name
+    self.dynamicArgumentTypes = dynamicArgumentTypes
+    self.body = body
+  }
+
+  // MARK: - AnyFunction
+
+  let name: String
+
+  let dynamicArgumentTypes: [AnyDynamicType]
+
+  var argumentsCount: Int {
+    return dynamicArgumentTypes.count - (takesOwner ? 1 : 0)
+  }
+
+  var takesOwner: Bool = false
+
+  func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext, callback: @escaping (FunctionCallResult) -> ()) {
+    do {
+      let result = try call(by: owner, withArguments: args, appContext: appContext)
+      callback(.success(Conversions.convertFunctionResult(result)))
+    } catch let error as Exception {
+      callback(.failure(error))
+    } catch {
+      callback(.failure(UnexpectedException(error)))
+    }
+  }
+
+  // MARK: - AnySyncFunctionDefinition
+
+  func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext) throws -> Any {
+    do {
+      try validateArgumentsNumber(function: self, received: args.count)
+
+      var arguments = concat(
+        arguments: args,
+        withOwner: owner,
+        withPromise: nil,
+        forFunction: self,
+        appContext: appContext
+      )
+
+      // Convert JS values to non-JS native types.
+      arguments = try cast(jsValues: arguments, forFunction: self, appContext: appContext)
+
+      // Convert arguments to the types desired by the function.
+      arguments = try cast(arguments: arguments, forFunction: self, appContext: appContext)
+
+      let argumentsTuple = try Conversions.toTuple(arguments) as! Args
+      return try body(argumentsTuple)
+    } catch let error as Exception {
+      throw FunctionCallException(name).causedBy(error)
+    } catch {
+      throw UnexpectedException(error)
+    }
+  }
+
+  // MARK: - JavaScriptObjectBuilder
+
+  func build(appContext: AppContext) throws -> JavaScriptObject {
+    // 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 try appContext.runtime.createSyncFunction(name, argsCount: argumentsCount) { [weak appContext, self] this, args in
+      guard let appContext else {
+        throw Exceptions.AppContextLost()
+      }
+      let result = try self.call(by: this, withArguments: args, appContext: appContext)
+      return Conversions.convertFunctionResult(result, appContext: appContext, dynamicType: ~ReturnType.self)
+    }
+  }
+}

package/ios/{JavaScriptUtils.swift → Core/JavaScriptUtils.swift}

@@ -30,7 +30,7 @@ internal func cast(_ value: Any, toType type: AnyDynamicType, appContext: AppCon
  - 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 cast(arguments: [Any], forFunction function: AnyFunction, appContext: AppContext) throws -> [Any] {
+internal func cast(arguments: [Any], forFunction function: AnyFunctionDefinition, appContext: AppContext) throws -> [Any] {
   return try arguments.enumerated().map { index, argument in
     let argumentType = function.dynamicArgumentTypes[index]
 
@@ -45,7 +45,7 @@ internal func cast(arguments: [Any], forFunction function: AnyFunction, appConte
 /**
  Casts an array of JavaScript values to non-JavaScript types.
  */
-internal func cast(jsValues: [Any], forFunction function: AnyFunction, appContext: AppContext) throws -> [Any] {
+internal func cast(jsValues: [Any], forFunction function: AnyFunctionDefinition, appContext: AppContext) throws -> [Any] {
   // TODO: Replace `[Any]` with `[JavaScriptValue]` once we make sure only JS values are passed here
   return try jsValues.enumerated().map { index, jsValue in
     let type = function.dynamicArgumentTypes[index]
@@ -67,7 +67,7 @@ internal func cast(jsValues: [Any], forFunction function: AnyFunction, appContex
  Validates whether the number of received arguments is enough to call the given function.
  Throws `InvalidArgsNumberException` otherwise.
  */
-internal func validateArgumentsNumber(function: AnyFunction, received: Int) throws {
+internal func validateArgumentsNumber(function: AnyFunctionDefinition, received: Int) throws {
   let argumentsCount = function.argumentsCount
   let requiredArgumentsCount = function.requiredArgumentsCount
 
@@ -89,7 +89,7 @@ internal func concat(
   arguments: [Any],
   withOwner owner: AnyObject?,
   withPromise promise: Promise?,
-  forFunction function: AnyFunction,
+  forFunction function: AnyFunctionDefinition,
   appContext: AppContext
 ) -> [Any] {
   var result = arguments

package/ios/{Logging → Core/Logging}/LogHandlers.swift

@@ -2,12 +2,21 @@
 
 import os.log
 
+public func createOSLogHandler(category: String) -> LogHandler {
+  if #available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *) {
+    return OSLogHandler(category: category)
+  }
+  return PrintLogHandler()
+}
+
+public func createPersistentFileLogHandler(category: String) -> LogHandler {
+  return PersistentFileLogHandler(category: category)
+}
+
 /**
  The protocol that needs to be implemented by log handlers.
  */
-internal protocol LogHandler {
-  init(category: String)
-
+public protocol LogHandler {
   func log(type: LogType, _ message: String)
 }
 
@@ -31,8 +40,6 @@ internal class OSLogHandler: LogHandler {
  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/{Logging → Core/Logging}/Logger.swift

@@ -2,30 +2,9 @@
 
 import Dispatch
 
-public let log = Logger(category: Logger.EXPO_LOG_CATEGORY)
+public let log = Logger(logHandlers: [createOSLogHandler(category: Logger.EXPO_LOG_CATEGORY)])
 
-/**
- An OptionSet defining the logging options that are currently supported.
- Future options may include writing to a DB or other destinations
- */
-public struct LoggerOptions: OptionSet {
-  public let rawValue: Int
-
-  public init(rawValue: Int) {
-    self.rawValue = rawValue
-  }
-
-  /**
-   Including this option will result in logs being written using os.log() or print(),
-   depending on the iOS version.
-   */
-  public static let logToOS = LoggerOptions(rawValue: 1 << 0)
-  /**
-   Including this option will result in logs being written to a flat file, as
-   strings separated by carriage returns.
-   */
-  public static let logToFile = LoggerOptions(rawValue: 1 << 1)
-}
+public typealias LoggerTimerFormatterBlock = (_ duration: Double) -> String
 
 /**
  Native iOS logging class for Expo, with options to direct logs
@@ -41,31 +20,10 @@ public class Logger {
   private var minLevel: LogType = .info
   #endif
 
-  private let category: String
-
-  private var handlers: [LogHandler] = []
-
-  public init(category: String = "main", options: LoggerOptions = [.logToOS]) {
-    self.category = category
-
-    if options.contains(.logToFile) {
-      addHandler(withType: PersistentFileLogHandler.self)
-    }
-    if options.contains(.logToOS) {
-      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)
-  }
+  private let logHandlers: [LogHandler]
 
-  internal func addHandler<LogHandlerType: LogHandler>(withType: LogHandlerType.Type) {
-    addHandler(LogHandlerType(category: category))
+  public required init(logHandlers: [LogHandler]) {
+    self.logHandlers = logHandlers
   }
 
   // MARK: - Public logging functions
@@ -146,52 +104,16 @@ public class Logger {
   // MARK: - Timers
 
   /**
-   Stores the timers created by `timeStart` function.
+   Starts a timer that can be used to compute the duration of an operation. Upon calling
+   `stop` on the returned object, a timer entry will be logged.
    */
-  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
+  public func startTimer(_ formatterBlock: @escaping LoggerTimerFormatterBlock) -> LoggerTimer {
+    let startTime = DispatchTime.now()
+    return LoggerTimer {
+      let endTime = DispatchTime.now()
+      let diff = Double(endTime.uptimeNanoseconds - startTime.uptimeNanoseconds) / 1_000_000
+      self.log(type: .timer, formatterBlock(diff))
     }
-    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) ms")
-    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
@@ -206,7 +128,7 @@ public class Logger {
       .split(whereSeparator: \.isNewline)
       .map { "\(type.prefix) \($0)" }
 
-    handlers.forEach { handler in
+    logHandlers.forEach { handler in
       messages.forEach { message in
         handler.log(type: type, message)
       }

package/ios/Core/Logging/LoggerTimer.swift

@@ -0,0 +1,22 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+import Foundation
+
+typealias LoggerTimerStopBlock = () -> Void
+
+/**
+ An instance of a timer.
+ */
+public class LoggerTimer {
+  private let stopBlock: LoggerTimerStopBlock
+
+  internal required init(stopBlock: @escaping LoggerTimerStopBlock) {
+    self.stopBlock = stopBlock
+  }
+  /**
+   End the timer and log a timer entry.
+   */
+  public func stop() {
+    self.stopBlock()
+  }
+}

package/ios/{ModuleHolder.swift → Core/ModuleHolder.swift}

@@ -31,13 +31,6 @@ public final class ModuleHolder {
     return definition.name.isEmpty ? String(describing: type(of: module)) : definition.name
   }
 
-  /**
-   Shortcut to get the underlying view manager definition.
-   */
-  var viewManager: ViewManagerDefinition? {
-    return definition.viewManager
-  }
-
   /**
    Number of JavaScript listeners attached to the module.
    */
@@ -75,7 +68,7 @@ public final class ModuleHolder {
 
   @discardableResult
   func callSync(function functionName: String, args: [Any]) -> Any? {
-    guard let appContext, let function = definition.functions[functionName] as? AnySyncFunctionComponent else {
+    guard let appContext, let function = definition.functions[functionName] as? AnySyncFunctionDefinition else {
       return nil
     }
     do {
@@ -83,8 +76,7 @@ public final class ModuleHolder {
       let result = try function.call(by: self, withArguments: arguments, appContext: appContext)
 
       if let result = result as? SharedObject {
-        let jsObject = SharedObjectRegistry.ensureSharedJavaScriptObject(runtime: try appContext.runtime, nativeObject: result)
-        return jsObject
+        return appContext.sharedObjectRegistry.ensureSharedJavaScriptObject(runtime: try appContext.runtime, nativeObject: result)
       }
       return result
     } catch {

package/ios/Core/Modules/CoreModule.swift

@@ -0,0 +1,43 @@
+// The core module that describes the `global.expo` object.
+internal final class CoreModule: Module {
+  internal func definition() -> ModuleDefinition {
+    // Expose some common classes and maybe even the `modules` host object in the future.
+    Function("uuidv4") { () -> String in
+      return UUID().uuidString.lowercased()
+    }
+
+    Function("uuidv5") { (name: String, namespace: String) -> String in
+      guard let namespaceUuid = UUID(uuidString: namespace) else {
+        throw InvalidNamespaceException(namespace)
+      }
+
+      return uuidv5(name: name, namespace: namespaceUuid).uuidString.lowercased()
+    }
+
+    Function("getViewConfig") { (viewName: String) -> [String: Any]? in
+      var validAttributes: [String: Any] = [:]
+      var directEventTypes: [String: Any] = [:]
+      let moduleHolder = appContext?.moduleRegistry.get(moduleHolderForName: viewName)
+
+      guard let viewDefinition = moduleHolder?.definition.view else {
+        return nil
+      }
+      for prop in viewDefinition.props {
+        validAttributes[prop.name] = true
+      }
+      for eventName in viewDefinition.eventNames {
+        guard let normalizedEventName = RCTNormalizeInputEventName(eventName) else {
+          continue
+        }
+        directEventTypes[normalizedEventName] = [
+          "registrationName": eventName
+        ]
+      }
+
+      return [
+        "validAttributes": validAttributes,
+        "directEventTypes": directEventTypes
+      ]
+    }
+  }
+}

package/ios/{Modules → Core/Modules}/ModuleDefinition.swift

@@ -1,8 +1,3 @@
-/**
- A protocol that must be implemented to be a part of module's definition and the module definition itself.
- */
-public protocol AnyDefinition {}
-
 /**
  The definition of the module. It is used to define some parameters
  of the module and what it exports to the JavaScript world.
@@ -20,13 +15,16 @@ public final class ModuleDefinition: ObjectDefinition {
   var name: String
 
   let eventListeners: [EventListener]
-  let viewManager: ViewManagerDefinition?
+
+  let view: AnyViewDefinition?
 
   /**
    Names of the events that the module can send to JavaScript.
    */
   let eventNames: [String]
 
+  let eventObservers: [AnyEventObservingDefinition]
+
   /**
    Initializer that is called by the `ModuleDefinitionBuilder` results builder.
    */
@@ -38,8 +36,8 @@ public final class ModuleDefinition: ObjectDefinition {
 
     self.eventListeners = definitions.compactMap { $0 as? EventListener }
 
-    self.viewManager = definitions
-      .compactMap { $0 as? ViewManagerDefinition }
+    self.view = definitions
+      .compactMap { $0 as? AnyViewDefinition }
       .last
 
     self.eventNames = Array(
@@ -48,6 +46,9 @@ public final class ModuleDefinition: ObjectDefinition {
         .joined()
     )
 
+    self.eventObservers = definitions
+      .compactMap { $0 as? AnyEventObservingDefinition }
+
     super.init(definitions: definitions)
   }
 
@@ -66,14 +67,21 @@ public final class ModuleDefinition: ObjectDefinition {
   }
 
   public override func build(appContext: AppContext) throws -> JavaScriptObject {
-    let object = try super.build(appContext: appContext)
+    // Create an instance of `global.expo.NativeModule`
+    let object = JSIUtils.createNativeModuleObject(try appContext.runtime)
+
+    try super.decorate(object: object, appContext: appContext)
 
-    if let viewManager {
-      let reactComponentPrototype = try appContext.runtime.createObject()
-      try viewManager.decorateWithFunctions(object: reactComponentPrototype, appContext: appContext)
+    if let viewDefinition = view {
+      let reactComponentPrototype = try viewDefinition.createReactComponentPrototype(appContext: appContext)
       object.setProperty("ViewPrototype", value: reactComponentPrototype)
     }
 
+    if !eventObservers.isEmpty {
+      try EventObservingDecorator(definitions: eventObservers)
+        .decorate(object: object, appContext: appContext)
+    }
+
     // Give the module object a name. It's used for compatibility reasons, see `EventEmitter.ts`.
     object.defineProperty("__expo_module_name__", value: name, options: [])
 

package/ios/{Modules → Core/Modules}/ModuleDefinitionBuilder.swift

@@ -1,7 +1,6 @@
-#if swift(>=5.4)
 /**
  A function builder that provides DSL-like syntax. Thanks to this, the function doesn't need to explicitly return an array,
- but can just return multiple components one after another. This works similarly to SwiftUI's `body` block.
+ but can just return multiple definitions one after another. This works similarly to SwiftUI's `body` block.
  */
 @resultBuilder
 public struct ModuleDefinitionBuilder {
@@ -9,4 +8,3 @@ public struct ModuleDefinitionBuilder {
     return ModuleDefinition(definitions: definitions)
   }
 }
-#endif

package/ios/{Objects → Core/Objects}/ObjectDefinition.swift

@@ -7,7 +7,7 @@ public class ObjectDefinition: AnyDefinition, JavaScriptObjectBuilder {
   /**
    A dictionary of functions defined by the object.
    */
-  let functions: [String: AnyFunction]
+  let functions: [String: AnyFunctionDefinition]
 
   /**
    An array of constants definitions.
@@ -17,20 +17,20 @@ public class ObjectDefinition: AnyDefinition, JavaScriptObjectBuilder {
   /**
    A map of dynamic properties defined by the object.
    */
-  let properties: [String: AnyPropertyComponent]
+  let properties: [String: AnyPropertyDefinition]
 
   /**
    A map of classes defined within the object.
    */
-  let classes: [String: ClassComponent]
+  let classes: [String: ClassDefinition]
 
   /**
    Default initializer receiving children definitions from the result builder.
    */
   init(definitions: [AnyDefinition]) {
     self.functions = definitions
-      .compactMap { $0 as? AnyFunction }
-      .reduce(into: [String: AnyFunction]()) { dict, function in
+      .compactMap { $0 as? AnyFunctionDefinition }
+      .reduce(into: [String: AnyFunctionDefinition]()) { dict, function in
         dict[function.name] = function
       }
 
@@ -38,14 +38,14 @@ public class ObjectDefinition: AnyDefinition, JavaScriptObjectBuilder {
       .compactMap { $0 as? ConstantsDefinition }
 
     self.properties = definitions
-      .compactMap { $0 as? AnyPropertyComponent }
-      .reduce(into: [String: AnyPropertyComponent]()) { dict, property in
+      .compactMap { $0 as? AnyPropertyDefinition }
+      .reduce(into: [String: AnyPropertyDefinition]()) { dict, property in
         dict[property.name] = property
       }
 
     self.classes = definitions
-      .compactMap { $0 as? ClassComponent }
-      .reduce(into: [String: ClassComponent]()) { dict, klass in
+      .compactMap { $0 as? ClassDefinition }
+      .reduce(into: [String: ClassDefinition]()) { dict, klass in
         dict[klass.name] = klass
       }
   }