expo-modules-core 0.9.2 → 0.10.0

package/ios/Swift/Logging/Logger.swift

@@ -0,0 +1,198 @@
+// 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? 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
+  }
+}

package/ios/Swift/Objects/ObjectDefinition.swift

@@ -3,7 +3,7 @@
 /**
  Base class for other definitions representing an object, such as `ModuleDefinition`.
  */
-public class ObjectDefinition: AnyDefinition {
+public class ObjectDefinition: AnyDefinition, JavaScriptObjectBuilder {
   /**
    A dictionary of functions defined by the object.
    */
@@ -14,6 +14,16 @@ public class ObjectDefinition: AnyDefinition {
    */
   let constants: [ConstantsDefinition]
 
+  /**
+   A map of dynamic properties defined by the object.
+   */
+  let properties: [String: PropertyComponent]
+
+  /**
+   A map of classes defined within the object.
+   */
+  let classes: [String: ClassComponent]
+
   /**
    Default initializer receiving children definitions from the result builder.
    */
@@ -26,5 +36,68 @@ public class ObjectDefinition: AnyDefinition {
 
     self.constants = definitions
       .compactMap { $0 as? ConstantsDefinition }
+
+    self.properties = definitions
+      .compactMap { $0 as? PropertyComponent }
+      .reduce(into: [String: PropertyComponent]()) { dict, property in
+        dict[property.name] = property
+      }
+
+    self.classes = definitions
+      .compactMap { $0 as? ClassComponent }
+      .reduce(into: [String: ClassComponent]()) { dict, klass in
+        dict[klass.name] = klass
+      }
+  }
+
+  /**
+   Merges all `constants` definitions into one dictionary.
+   */
+  func getConstants() -> [String: Any?] {
+    return constants.reduce(into: [String: Any?]()) { dict, definition in
+      dict.merge(definition.body()) { $1 }
+    }
+  }
+
+  // MARK: - JavaScriptObjectBuilder
+
+  public func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
+    let object = runtime.createObject()
+    decorate(object: object, inRuntime: runtime)
+    return object
+  }
+
+  public func decorate(object: JavaScriptObject, inRuntime runtime: JavaScriptRuntime) {
+    decorateWithConstants(runtime: runtime, object: object)
+    decorateWithFunctions(runtime: runtime, object: object)
+    decorateWithProperties(runtime: runtime, object: object)
+    decorateWithClasses(runtime: runtime, object: object)
+  }
+
+  // MARK: - Internals
+
+  internal func decorateWithConstants(runtime: JavaScriptRuntime, object: JavaScriptObject) {
+    for (key, value) in getConstants() {
+      object.setProperty(key, value: value)
+    }
+  }
+
+  internal func decorateWithFunctions(runtime: JavaScriptRuntime, object: JavaScriptObject) {
+    for fn in functions.values {
+      object.setProperty(fn.name, value: fn.build(inRuntime: runtime))
+    }
+  }
+
+  internal func decorateWithProperties(runtime: JavaScriptRuntime, object: JavaScriptObject) {
+    for property in properties.values {
+      let descriptor = property.buildDescriptor(inRuntime: runtime, withCaller: object)
+      object.defineProperty(property.name, descriptor: descriptor)
+    }
+  }
+
+  internal func decorateWithClasses(runtime: JavaScriptRuntime, object: JavaScriptObject) {
+    for klass in classes.values {
+      object.setProperty(klass.name, value: klass.build(inRuntime: runtime))
+    }
   }
 }