expo-modules-core 0.6.1 → 0.7.0

package/ios/Swift/{CodedError.swift → Exceptions/CodedError.swift}

@@ -18,7 +18,7 @@ public extension CodedError {
    */
   var code: String {
     let className = String(describing: type(of: self))
-      .replacingOccurrences(of: #"(Error)?(<.*>)?$"#, with: "", options: .regularExpression)
+      .replacingOccurrences(of: #"(Error|Exception)?(<.*>)?$"#, with: "", options: .regularExpression)
     let regex = try! NSRegularExpression(pattern: "(.)([A-Z])", options: [])
     let range = NSRange(location: 0, length: className.count)
 
@@ -48,14 +48,3 @@ public struct SimpleCodedError: CodedError {
     self.description = description
   }
 }
-
-/**
- Coded wrapper for uncoded errors. Intended to be used to handle unexpected native errors.
- */
-public struct UnexpectedError: CodedError {
-  public let description: String
-
-  init(_ error: Error) {
-    self.description = error.localizedDescription
-  }
-}

package/ios/Swift/Exceptions/Exception.swift

@@ -0,0 +1,62 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+open class Exception: CodedError, ChainableException, CustomStringConvertible, CustomDebugStringConvertible {
+  open var name: String {
+    return String(describing: Self.self)
+  }
+
+  /**
+   String describing the reason of the exception.
+   */
+  open var reason: String {
+    "undefined reason"
+  }
+
+  /**
+   The origin in code where the exception was created.
+   */
+  open var origin: ExceptionOrigin
+
+  /**
+   The default initializer that captures the place in the code where the exception was created.
+   - Warning: Call it only without arguments!
+   */
+  public init(file: String = #fileID, line: UInt = #line, function: String = #function) {
+    self.origin = ExceptionOrigin(file: file, line: line, function: function)
+  }
+
+  // MARK: ChainableException
+
+  open var cause: Error?
+
+  // MARK: CustomStringConvertible
+
+  open var description: String {
+    return concatDescription(reason, withCause: cause, debug: false)
+  }
+
+  // MARK: CustomDebugStringConvertible
+
+  open var debugDescription: String {
+    let debugDescription = "\(name): \(reason) (at \(origin.file):\(origin.line))"
+    return concatDescription(debugDescription, withCause: cause, debug: true)
+  }
+}
+
+/**
+ Concatenates the exception description with its cause description.
+ */
+private func concatDescription(_ description: String, withCause cause: Error?, debug: Bool = false) -> String {
+  let causeSeparator = "\n→ Caused by: "
+  switch cause {
+  case let cause as Exception:
+    return description + causeSeparator + (debug ? cause.debugDescription : cause.description)
+  case let cause as CodedError:
+    // `CodedError` is deprecated but we need to provide backwards compatibility as some modules already used it.
+    return description + causeSeparator + cause.description
+  case let cause?:
+    return description + causeSeparator + cause.localizedDescription
+  default:
+    return description
+  }
+}

package/ios/Swift/Exceptions/ExceptionOrigin.swift

@@ -0,0 +1,28 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Represents the place in code where the exception was created.
+ */
+public struct ExceptionOrigin: CustomStringConvertible {
+  /**
+   The path to the file in which the exception was created.
+   */
+  let file: String
+
+  /**
+   The line number on which the exception was created.
+   */
+  let line: UInt
+
+  /**
+   The name (selector) of the declaration in which the exception was created.
+   */
+  let function: String
+
+  /**
+   Stringified representation of the exception origin.
+   */
+  public var description: String {
+    "at \(file):\(line) in \(function)"
+  }
+}

package/ios/Swift/Exceptions/GenericException.swift

@@ -0,0 +1,20 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ The exception that needs some additional parameters to be best described.
+ */
+open class GenericException<ParamType>: Exception {
+  /**
+   The additional parameter passed to the initializer.
+   */
+  public let param: ParamType
+
+  /**
+   The default initializer that takes a param and captures the place in the code where the exception was created.
+   - Warning: Call it only with one argument! If you need to pass more parameters, use a tuple instead.
+   */
+  public init(_ param: ParamType, file: String = #fileID, line: UInt = #line, function: String = #function) {
+    self.param = param
+    super.init(file: file, line: line, function: function)
+  }
+}

package/ios/Swift/Exceptions/UnexpectedException.swift

@@ -0,0 +1,16 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Exception wrapper used to handle unexpected internal native errors.
+ */
+public class UnexpectedException: Exception {
+  private let errorDescription: String
+
+  public init(_ error: Error) {
+    self.errorDescription = error.localizedDescription
+  }
+
+  public override var reason: String {
+    return errorDescription
+  }
+}

package/ios/Swift/Functions/AnyFunction.swift

@@ -24,10 +24,15 @@ public protocol AnyFunction: AnyDefinition {
    */
   var queue: DispatchQueue? { get }
 
+  /**
+   Whether the function needs to be called asynchronously from JavaScript.
+   */
+  var isAsync: Bool { get }
+
   /**
    Calls the function on given module with arguments and a promise.
    */
-  func call(args: [Any], promise: Promise) -> Void
+  func call(args: [Any], promise: Promise)
 
   /**
    Synchronously calls the function with given arguments. If the function takes a promise,
@@ -39,4 +44,9 @@ public protocol AnyFunction: AnyDefinition {
    Specifies on which queue the function should run.
    */
   func runOnQueue(_ queue: DispatchQueue?) -> Self
+
+  /**
+   Makes the JavaScript function synchronous.
+   */
+  func runSynchronously() -> Self
 }

package/ios/Swift/Functions/ConcreteFunction.swift

@@ -1,7 +1,7 @@
 import Dispatch
 
 public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
-  public typealias ClosureType = (Args) -> ReturnType
+  public typealias ClosureType = (Args) throws -> ReturnType
 
   public let name: String
 
@@ -15,6 +15,8 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
 
   public var queue: DispatchQueue?
 
+  public var isAsync: Bool = true
+
   let closure: ClosureType
 
   let argTypes: [AnyArgumentType]
@@ -41,12 +43,12 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
       }
 
       let tuple = try Conversions.toTuple(finalArgs) as! Args
-      returnedValue = closure(tuple)
+      returnedValue = try closure(tuple)
     } catch let error as CodedError {
-      promise.reject(error)
+      promise.reject(FunctionCallException(name).causedBy(error))
       return
-    } catch let error {
-      promise.reject(UnexpectedError(error))
+    } catch {
+      promise.reject(UnexpectedException(error))
       return
     }
     if !takesPromise {
@@ -62,7 +64,7 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
       let promise = Promise {
         result = $0
         semaphore.signal()
-      } rejecter: { error in
+      } rejecter: { _ in
         semaphore.signal()
       }
       call(args: args, promise: promise)
@@ -72,7 +74,7 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
       do {
         let finalArgs = try castArguments(args)
         let tuple = try Conversions.toTuple(finalArgs) as! Args
-        return closure(tuple)
+        return try closure(tuple)
       } catch let error {
         return error
       }
@@ -84,27 +86,46 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
     return self
   }
 
+  public func runSynchronously() -> Self {
+    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 InvalidArgsNumberError(received: args.count, expected: argumentsCount)
+      throw InvalidArgsNumberException((received: args.count, expected: argumentsCount))
     }
-    return try args.enumerated().map { (index, arg) in
+    return try args.enumerated().map { index, arg in
       let expectedType = argumentType(atIndex: index)
 
-      // It's safe to unwrap since the arguments count matches.
-      return try expectedType!.cast(arg)
+      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 struct InvalidArgsNumberError: CodedError {
-  let received: Int
-  let expected: Int
-  var description: String {
-    "Received \(received) arguments, but \(expected) was expected."
+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> {
+  override var reason: String {
+    "Call to function '\(param)' has been rejected"
   }
 }

package/ios/Swift/JavaScriptUtils.swift

@@ -0,0 +1,43 @@
+// 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)
+  }
+}
+
+private class ModuleUnavailableException: GenericException<String> {
+  override var reason: String {
+    "Module '\(param)' is no longer available"
+  }
+}

package/ios/Swift/ModuleHolder.swift

@@ -14,6 +14,11 @@ public final class ModuleHolder {
    */
   private(set) weak var appContext: AppContext?
 
+  /**
+   JavaScript object that represents the module instance in the runtime.
+   */
+  public internal(set) lazy var javaScriptObject: JavaScriptObject? = createJavaScriptModuleObject()
+
   /**
    Caches the definition of the module type.
    */
@@ -26,6 +31,13 @@ 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.
    */
@@ -54,7 +66,7 @@ public final class ModuleHolder {
   func call(function functionName: String, args: [Any], promise: Promise) {
     do {
       guard let function = definition.functions[functionName] else {
-        throw FunctionNotFoundError(functionName: functionName, moduleName: self.name)
+        throw FunctionNotFoundException((functionName: functionName, moduleName: self.name))
       }
       let queue = function.queue ?? DispatchQueue.global(qos: .default)
 
@@ -64,7 +76,7 @@ public final class ModuleHolder {
     } catch let error as CodedError {
       promise.reject(error)
     } catch {
-      promise.reject(UnexpectedError(error))
+      promise.reject(UnexpectedException(error))
     }
   }
 
@@ -85,6 +97,36 @@ public final class ModuleHolder {
     return nil
   }
 
+  // MARK: JavaScript Module Object
+
+  /**
+   Creates the JavaScript object that will be used to communicate with the native module.
+   The object is prefilled with module's constants and functions.
+   JavaScript can access it through `global.ExpoModules[moduleName]`.
+   - Note: The object will be `nil` when the runtime is unavailable (e.g. remote debugger is enabled).
+   */
+  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 {
+      return nil
+    }
+
+    // Fill in with constants
+    for (key, value) in getConstants() {
+      object[key] = 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
+  }
+
   // MARK: Listening to native events
 
   func listeners(forEvent event: EventName) -> [EventListener] {
@@ -112,9 +154,9 @@ public final class ModuleHolder {
    */
   func modifyListenersCount(_ count: Int) {
     if count > 0 && listenersCount == 0 {
-      let _ = definition.functions["startObserving"]?.callSync(args: [])
+      _ = definition.functions["startObserving"]?.callSync(args: [])
     } else if count < 0 && listenersCount + count <= 0 {
-      let _ = definition.functions["stopObserving"]?.callSync(args: [])
+      _ = definition.functions["stopObserving"]?.callSync(args: [])
     }
     listenersCount = max(0, listenersCount + count)
   }
@@ -125,20 +167,17 @@ public final class ModuleHolder {
     post(event: .moduleDestroy)
   }
 
-  // MARK: Errors
+  // MARK: - Exceptions
 
-  struct ModuleNotFoundError: CodedError {
-    let moduleName: String
-    var description: String {
-      "Cannot find module `\(moduleName)`"
+  internal class ModuleNotFoundException: GenericException<String> {
+    override var reason: String {
+      "Module '\(param)' not found"
     }
   }
 
-  struct FunctionNotFoundError: CodedError {
-    let functionName: String
-    let moduleName: String
-    var description: String {
-      "Cannot find function `\(functionName)` in module `\(moduleName)`"
+  internal class FunctionNotFoundException: GenericException<(functionName: String, moduleName: String)> {
+    override var reason: String {
+      "Function '\(param.functionName)' not found in module '\(param.moduleName)'"
     }
   }
 }

package/ios/Swift/ModuleRegistry.swift

@@ -1,4 +1,3 @@
-
 public final class ModuleRegistry: Sequence {
   public typealias Element = ModuleHolder
 
@@ -63,6 +62,10 @@ public final class ModuleRegistry: Sequence {
     return registry[moduleName]?.module
   }
 
+  public func getModuleNames() -> [String] {
+    return Array(registry.keys)
+  }
+
   public func makeIterator() -> IndexingIterator<[ModuleHolder]> {
     return registry.map({ $1 }).makeIterator()
   }

package/ios/Swift/Modules/AnyModule.swift

@@ -1,4 +1,3 @@
-
 /**
  A protocol for any type-erased module that provides functions used by the core.
  */

package/ios/Swift/Modules/ModuleDefinition.swift

@@ -1,4 +1,3 @@
-
 /**
  A protocol that must be implemented to be a part of module's definition and the module definition itself.
  */
@@ -9,7 +8,7 @@ public protocol AnyDefinition {}
  of the module and what it exports to the JavaScript world.
  See `ModuleDefinitionBuilder` for more details on how to create it.
  */
-public final class ModuleDefinition: AnyDefinition {
+public final class ModuleDefinition: ObjectDefinition {
   /**
    The module's type associated with the definition. It's used to create the module instance.
    */
@@ -20,8 +19,6 @@ public final class ModuleDefinition: AnyDefinition {
    */
   var name: String
 
-  let functions: [String : AnyFunction]
-  let constants: [ConstantsDefinition]
   let eventListeners: [EventListener]
   let viewManager: ViewManagerDefinition?
 
@@ -33,20 +30,12 @@ public final class ModuleDefinition: AnyDefinition {
   /**
    Initializer that is called by the `ModuleDefinitionBuilder` results builder.
    */
-  init(definitions: [AnyDefinition]) {
+  override init(definitions: [AnyDefinition]) {
     self.name = definitions
       .compactMap { $0 as? ModuleNameDefinition }
       .last?
       .name ?? ""
 
-    self.functions = definitions
-      .compactMap { $0 as? AnyFunction }
-      .reduce(into: [String : AnyFunction]()) { dict, function in
-        dict[function.name] = function
-      }
-
-    self.constants = definitions.compactMap { $0 as? ConstantsDefinition }
-
     self.eventListeners = definitions.compactMap { $0 as? EventListener }
 
     self.viewManager = definitions
@@ -58,6 +47,8 @@ public final class ModuleDefinition: AnyDefinition {
         .compactMap { ($0 as? EventsDefinition)?.names }
         .joined()
     )
+
+    super.init(definitions: definitions)
   }
 
   /**

package/ios/Swift/Modules/ModuleDefinitionBuilder.swift

@@ -1,4 +1,3 @@
-
 #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,