expo-modules-core 0.9.2 → 0.10.0

package/ios/Swift/Arguments/{Types/EnumArgumentType.swift → EnumArgument.swift}

@@ -1,19 +1,4 @@
-// Copyright 2021-present 650 Industries. All rights reserved.
-
-/**
- An argument type representing an enum that conforms to `EnumArgument`.
- */
-internal struct EnumArgumentType: AnyArgumentType {
-  let innerType: EnumArgument.Type
-
-  func cast<ArgType>(_ value: ArgType) throws -> Any {
-    return try innerType.create(fromRawValue: value)
-  }
-
-  var description: String {
-    "Enum<\(innerType)>"
-  }
-}
+// Copyright 2022-present 650 Industries. All rights reserved.
 
 /**
  A protocol that allows converting raw values to enum cases.
@@ -23,7 +8,7 @@ public protocol EnumArgument: AnyArgument {
    Tries to create an enum case using given raw value.
    May throw errors, e.g. when the raw value doesn't match any case.
    */
-  static func create<ArgType>(fromRawValue rawValue: ArgType) throws -> Self
+  static func create<RawValueType>(fromRawValue rawValue: RawValueType) throws -> Self
 
   /**
    Returns an array of all raw values available in the enum.

package/ios/Swift/Classes/ClassComponent.swift

@@ -0,0 +1,95 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Represents a JavaScript class.
+ */
+public final class ClassComponent: ObjectDefinition {
+  /**
+   Name of the class.
+   */
+  let name: String
+
+  /**
+   A synchronous function that gets called when the object of this class is initializing.
+   */
+  let constructor: AnySyncFunctionComponent?
+
+  /**
+   A dynamic type for the associated object class.
+   */
+  let associatedType: AnyDynamicType?
+
+  init<AssociatedObject: ClassAssociatedObject>(
+    name: String,
+    associatedType: AssociatedObject.Type,
+    elements: [AnyClassComponentElement] = []
+  ) {
+    self.name = name
+    self.constructor = elements.first(where: isConstructor) as? AnySyncFunctionComponent
+    self.associatedType = ~AssociatedObject.self
+
+    // Constructors can't be passed down to the object component
+    // as we shouldn't override the default `<Class>.prototype.constructor`.
+    let elementsWithoutConstructors = elements.filter({ !isConstructor($0) })
+
+    super.init(definitions: elementsWithoutConstructors)
+  }
+
+  // MARK: - JavaScriptObjectBuilder
+
+  public override func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
+    let klass = runtime.createClass(name) { [weak self, weak runtime] this, arguments in
+      guard let self = self, let runtime = runtime else {
+        // TODO: Throw an exception? (@tsapeta)
+        return
+      }
+      // The properties can't go into the prototype as they would be shared across all instances.
+      // Instead, we decorate the instance object on initialization.
+      self.decorateWithProperties(runtime: runtime, object: this)
+
+      // Call the native constructor when defined.
+      let result = try? self.constructor?.call(by: this, withArguments: arguments)
+
+      // Register the shared object if returned by the constructor.
+      if let result = result as? SharedObject {
+        SharedObjectRegistry.add(native: result, javaScript: this)
+      }
+    }
+    decorate(object: klass, inRuntime: runtime)
+    return klass
+  }
+
+  public override func decorate(object: JavaScriptObject, inRuntime runtime: JavaScriptRuntime) {
+    // Here we actually don't decorate the input object (constructor) but its prototype.
+    // Properties are intentionally skipped here — they have to decorate an instance instead of the prototype.
+    let prototype = object.getProperty("prototype").getObject()
+    decorateWithConstants(runtime: runtime, object: prototype)
+    decorateWithFunctions(runtime: runtime, object: prototype)
+    decorateWithClasses(runtime: runtime, object: prototype)
+  }
+}
+
+// MARK: - ClassAssociatedObject
+
+/**
+ A protocol for types that can be used an associated type of the `ClassComponent`.
+ */
+internal protocol ClassAssociatedObject {}
+
+// Basically we only need these two
+extension JavaScriptObject: ClassAssociatedObject {}
+extension SharedObject: ClassAssociatedObject {}
+
+// MARK: - Privates
+
+/**
+ Checks whether the definition item is a constructor — a synchronous function whose name is "constructor".
+
+ We do it that way for the following two reasons:
+ - It's easier to reuse existing `SyncFunctionComponent`.
+ - Redefining prototype's `constructor` is a bad idea so a function with this name
+   needs to be filtered out when decorating the prototype.
+ */
+fileprivate func isConstructor(_ item: AnyDefinition) -> Bool {
+  return (item as? AnySyncFunctionComponent)?.name == "constructor"
+}

package/ios/Swift/Classes/ClassComponentElement.swift

@@ -0,0 +1,33 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ A type-erased protocol that must be implemented by the components passed as ``ClassComponent`` elements.
+ */
+public protocol AnyClassComponentElement: AnyDefinition {}
+
+/**
+ Class component element with an associated owner type. The `OwnerType` should refer to
+ the type that the parent `Class` component is associated with (e.g. the shared object type).
+ */
+public protocol ClassComponentElement: AnyClassComponentElement {
+  associatedtype OwnerType
+}
+
+// MARK: - Conformance
+// Allow some other components to be used as the class component elements.
+
+extension SyncFunctionComponent: ClassComponentElement {
+  public typealias OwnerType = FirstArgType
+}
+
+extension AsyncFunctionComponent: ClassComponentElement {
+  public typealias OwnerType = FirstArgType
+}
+
+extension PropertyComponent: ClassComponentElement {
+  public typealias OwnerType = Void
+}
+
+extension ConstantsDefinition: ClassComponentElement {
+  public typealias OwnerType = Void
+}

package/ios/Swift/Classes/ClassComponentElementsBuilder.swift

@@ -0,0 +1,34 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ A result builder that captures the ``ClassComponent`` elements such as functions, constants and properties.
+ */
+@resultBuilder
+public struct ClassComponentElementsBuilder<OwnerType> {
+  public static func buildBlock(_ elements: AnyClassComponentElement...) -> [AnyClassComponentElement] {
+    return elements
+  }
+
+  /**
+   Default implementation without any constraints that just returns type-erased element.
+   */
+  static func buildExpression<ElementType: ClassComponentElement>(
+    _ element: ElementType
+  ) -> AnyClassComponentElement {
+    return element
+  }
+
+  /**
+   In case the element's owner type matches builder's generic type,
+   we need to instruct the function to pass `this` to the closure
+   as the first argument and deduct it from `argumentsCount`.
+   */
+  static func buildExpression<ElementType: ClassComponentElement>(
+    _ element: ElementType
+  ) -> AnyClassComponentElement where ElementType.OwnerType == OwnerType {
+    if var function = element as? AnyFunction {
+      function.takesOwner = true
+    }
+    return element
+  }
+}

package/ios/Swift/Classes/ClassComponentFactories.swift

@@ -0,0 +1,96 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Class constructor without arguments.
+ */
+public func Constructor<R>(
+  _ body: @escaping () throws -> R
+) -> SyncFunctionComponent<(), Void, R> {
+  return Function("constructor", body)
+}
+
+/**
+ Class constructor with one argument.
+ */
+public func Constructor<R, A0: AnyArgument>(
+  _ body: @escaping (A0) throws -> R
+) -> SyncFunctionComponent<(A0), A0, R> {
+  return Function("constructor", body)
+}
+
+/**
+ Class constructor with two arguments.
+ */
+public func Constructor<R, A0: AnyArgument, A1: AnyArgument>(
+  _ body: @escaping (A0, A1) throws -> R
+) -> SyncFunctionComponent<(A0, A1), A0, R> {
+  return Function("constructor", body)
+}
+
+/**
+ Class constructor with three arguments.
+ */
+public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
+  _ body: @escaping (A0, A1, A2) throws -> R
+) -> SyncFunctionComponent<(A0, A1, A2), A0, R> {
+  return Function("constructor", body)
+}
+
+/**
+ Class constructor with four arguments.
+ */
+public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
+  _ body: @escaping (A0, A1, A2, A3) throws -> R
+) -> SyncFunctionComponent<(A0, A1, A2, A3), A0, R> {
+  return Function("constructor", body)
+}
+
+/**
+ Class constructor with five arguments.
+ */
+public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
+  _ body: @escaping (A0, A1, A2, A3, A4) throws -> R
+) -> SyncFunctionComponent<(A0, A1, A2, A3, A4), A0, R> {
+  return Function("constructor", body)
+}
+
+/**
+ Class constructor with six arguments.
+ */
+public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument>(
+  _ body: @escaping (A0, A1, A2, A3, A4, A5) throws -> R
+) -> SyncFunctionComponent<(A0, A1, A2, A3, A4, A5), A0, R> {
+  return Function("constructor", body)
+}
+
+/**
+ Creates the component describing a JavaScript class.
+ */
+public func Class(
+  _ name: String,
+  @ClassComponentElementsBuilder<JavaScriptObject> _ elements: () -> [AnyClassComponentElement]
+) -> ClassComponent {
+  return ClassComponent(name: name, associatedType: JavaScriptObject.self, elements: elements())
+}
+
+/**
+ Creates the component describing a JavaScript class with an associated native shared object class.
+ */
+public func Class<SharedObjectType: SharedObject>(
+  _ name: String = String(describing: SharedObjectType.self),
+  _ sharedObjectType: SharedObjectType.Type,
+  @ClassComponentElementsBuilder<SharedObjectType> _ elements: () -> [AnyClassComponentElement]
+) -> ClassComponent {
+  return ClassComponent(name: name, associatedType: SharedObjectType.self, elements: elements())
+}
+
+/**
+ Creates the component describing a JavaScript class with an associated native shared object class
+ and with the name that is inferred from the shared object type.
+ */
+public func Class<SharedObjectType: SharedObject>(
+  _ sharedObjectType: SharedObjectType.Type,
+  @ClassComponentElementsBuilder<SharedObjectType> _ elements: () -> [AnyClassComponentElement]
+) -> ClassComponent {
+  return ClassComponent(name: String(describing: SharedObjectType.self), associatedType: SharedObjectType.self, elements: elements())
+}

package/ios/Swift/DynamicTypes/AnyDynamicType.swift

@@ -0,0 +1,44 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A protocol whose intention is to wrap any type
+ to keep its real signature and not type-erase it by the compiler.
+ */
+public protocol AnyDynamicType: CustomStringConvertible {
+  /**
+   Checks whether the inner type is the same as the given type.
+   */
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool
+
+  /**
+   Checks whether the dynamic type is equal to another,
+   that is when the type of the dynamic types are equal and their inner types are equal.
+   */
+  func equals(_ type: AnyDynamicType) -> Bool
+
+  /**
+   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`).
+   */
+  func cast<ValueType>(_ value: ValueType) throws -> Any
+}
+
+// MARK: - Operators
+
+infix operator ~>
+public func ~> <T>(lhs: AnyDynamicType, rhs: T.Type) -> Bool {
+  return lhs.wraps(rhs)
+}
+
+infix operator !~>
+public func !~> <T>(lhs: AnyDynamicType, rhs: T.Type) -> Bool {
+  return !lhs.wraps(rhs)
+}
+
+public func == (lhs: AnyDynamicType, rhs: AnyDynamicType) -> Bool {
+  return lhs.equals(rhs)
+}
+
+public func != (lhs: AnyDynamicType, rhs: AnyDynamicType) -> Bool {
+  return !lhs.equals(rhs)
+}

package/ios/Swift/DynamicTypes/DynamicArrayType.swift

@@ -0,0 +1,56 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A dynamic type representing array types. Requires the array's element type
+ for the initialization as it delegates casting to that type for each element in the array.
+ */
+internal struct DynamicArrayType: AnyDynamicType {
+  let elementType: AnyDynamicType
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    if let ArrayType = InnerType.self as? AnyArray.Type {
+      return elementType.equals(ArrayType.getElementDynamicType())
+    }
+    return false
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    if let arrayType = type as? Self {
+      return arrayType.elementType.equals(elementType)
+    }
+    return false
+  }
+
+  func cast<ValueType>(_ value: ValueType) throws -> Any {
+    if let value = value as? [Any] {
+      return try value.map { try elementType.cast($0) }
+    }
+    // We should probably throw an error if we get here. On the other side, the array type
+    // requirement can be more loosen so we can try to arrayize values that are not arrays.
+    return [try elementType.cast(value)]
+  }
+
+  var description: String {
+    "[\(elementType.description)]"
+  }
+}
+
+/**
+ A type-erased protocol used to recognize if the generic type is an array type.
+ `Array` is a generic type, so it's impossible to check the inheritance directly.
+ */
+internal protocol AnyArray {
+  /**
+   Exposes the `Element` generic type wrapped by the dynamic type to preserve its metadata.
+   */
+  static func getElementDynamicType() -> AnyDynamicType
+}
+
+/**
+ Extends the `Array` type to expose its generic `Element` as a dynamic type.
+ */
+extension Array: AnyArray {
+  static func getElementDynamicType() -> AnyDynamicType {
+    return DynamicType(Element.self)
+  }
+}

package/ios/Swift/DynamicTypes/DynamicConvertibleType.swift

@@ -0,0 +1,27 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A dynamic type that wraps any type conforming to `ConvertibleArgument` protocol.
+ */
+internal struct DynamicConvertibleType: AnyDynamicType {
+  let innerType: ConvertibleArgument.Type
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    return innerType == InnerType.self
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    if let convertibleType = type as? Self {
+      return convertibleType.innerType == innerType
+    }
+    return false
+  }
+
+  func cast<ValueType>(_ value: ValueType) throws -> Any {
+    return try innerType.convert(from: value)
+  }
+
+  var description: String {
+    String(describing: innerType.self)
+  }
+}

package/ios/Swift/DynamicTypes/DynamicEnumType.swift

@@ -0,0 +1,27 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A dynamic type representing an enum that conforms to `EnumArgument`.
+ */
+internal struct DynamicEnumType: AnyDynamicType {
+  let innerType: EnumArgument.Type
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    return innerType == InnerType.self
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    if let enumType = type as? Self {
+      return enumType.innerType == innerType
+    }
+    return false
+  }
+
+  func cast<ValueType>(_ value: ValueType) throws -> Any {
+    return try innerType.create(fromRawValue: value)
+  }
+
+  var description: String {
+    "Enum<\(innerType)>"
+  }
+}

package/ios/Swift/DynamicTypes/DynamicOptionalType.swift

@@ -0,0 +1,63 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A dynamic type that represents an optional type, which allows `nil` to be passed when casting.
+ Requires the optional's wrapped type as it delegates casting to that type for non-nil values.
+ */
+internal struct DynamicOptionalType: AnyDynamicType {
+  let wrappedType: AnyDynamicType
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    if let OptionalType = InnerType.self as? AnyOptional.Type {
+      return wrappedType.equals(OptionalType.getWrappedDynamicType())
+    }
+    return false
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    if let optionalType = type as? Self {
+      return optionalType.wrappedType.equals(wrappedType)
+    }
+    return false
+  }
+
+  func cast<ValueType>(_ value: ValueType) throws -> Any {
+    if Optional.isNil(value) || value is NSNull {
+      return Optional<Any>.none as Any
+    }
+    return try wrappedType.cast(value)
+  }
+
+  var description: String {
+    "\(wrappedType)?"
+  }
+}
+
+/**
+ A type-erased protocol used to recognize if the generic type is an optional type.
+ `Optional` is a generic enum, so it's impossible to check the inheritance directly.
+ */
+internal protocol AnyOptional {
+  /**
+   Exposes the `Wrapped` generic type wrapped by the dynamic type to preserve its metadata.`
+   */
+  static func getWrappedDynamicType() -> AnyDynamicType
+}
+
+/**
+ Make generic `Optional` implement non-generic `AnyOptional` and add handy check against type-erased `nil`.
+ */
+extension Optional: AnyOptional {
+  static func getWrappedDynamicType() -> AnyDynamicType {
+    return DynamicType(Wrapped.self)
+  }
+
+  static func isNil(_ object: Wrapped) -> Bool {
+    switch object as Any {
+    case Optional<Any>.none:
+      return true
+    default:
+      return false
+    }
+  }
+}

package/ios/Swift/DynamicTypes/DynamicRawType.swift

@@ -0,0 +1,33 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A dynamic type that can wrap any type, but it casts only type-compatible values using `as?` keyword.
+ The innermost type of the other dynamic types like `ArrayArgumentType` and `OptionalArgumentType`.
+ */
+internal struct DynamicRawType<InnerType>: AnyDynamicType {
+  let innerType: InnerType.Type
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    return type == innerType
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    return type is Self
+  }
+
+  func cast<ValueType>(_ value: ValueType) throws -> Any {
+    if let value = value as? InnerType {
+      return value
+    }
+    // Raw types are always non-optional, but they may receive `nil` values.
+    // Let's throw more specific error in this case.
+    if Optional.isNil(value) {
+      throw Conversions.NullCastException<InnerType>()
+    }
+    throw Conversions.CastingException<InnerType>(value)
+  }
+
+  var description: String {
+    String(describing: innerType.self)
+  }
+}

package/ios/Swift/DynamicTypes/DynamicSharedObjectType.swift

@@ -0,0 +1,37 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ A dynamic type representing the `SharedObject` type and its subclasses.
+ */
+internal struct DynamicSharedObjectType: AnyDynamicType {
+  let innerType: SharedObject.Type
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    return innerType == InnerType.self
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    if let sharedObjectType = type as? Self {
+      return sharedObjectType.innerType == innerType
+    }
+    return false
+  }
+
+  func cast<ValueType>(_ value: ValueType) throws -> Any {
+    if let jsObject = try (value as? JavaScriptValue)?.asObject(),
+       let nativeSharedObject = SharedObjectRegistry.toNativeObject(jsObject) {
+      return nativeSharedObject
+    }
+    throw NativeSharedObjectNotFoundException()
+  }
+
+  var description: String {
+    return "SharedObject<\(innerType)>"
+  }
+}
+
+internal final class NativeSharedObjectNotFoundException: Exception {
+  override var reason: String {
+    "Unable to find the native shared object associated with given JavaScript object"
+  }
+}

package/ios/Swift/DynamicTypes/DynamicType.swift

@@ -0,0 +1,39 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+// Function names should start with a lowercase character, but in this one case
+// we want it to be uppercase as we treat it more like a generic class.
+// swiftlint:disable identifier_name
+
+/**
+ Factory creating an instance of the dynamic type wrapper conforming to `AnyDynamicType`.
+ Depending on the given type, it may return one of `DynamicArrayType`, `DynamicOptionalType`, `DynamicConvertibleType`, etc.
+ */
+internal func DynamicType<T>(_ type: T.Type) -> AnyDynamicType {
+  if let ArrayType = T.self as? AnyArray.Type {
+    return DynamicArrayType(elementType: ArrayType.getElementDynamicType())
+  }
+  if let OptionalType = T.self as? AnyOptional.Type {
+    return DynamicOptionalType(wrappedType: OptionalType.getWrappedDynamicType())
+  }
+  if let ConvertibleType = T.self as? ConvertibleArgument.Type {
+    return DynamicConvertibleType(innerType: ConvertibleType)
+  }
+  if let EnumType = T.self as? EnumArgument.Type {
+    return DynamicEnumType(innerType: EnumType)
+  }
+  if let SharedObjectType = T.self as? SharedObject.Type {
+    return DynamicSharedObjectType(innerType: SharedObjectType)
+  }
+  if let TypedArrayType = T.self as? AnyTypedArray.Type {
+    return DynamicTypedArrayType(innerType: TypedArrayType)
+  }
+  return DynamicRawType(innerType: T.self)
+}
+
+/**
+ Handy prefix operator that makes the dynamic type from the static type.
+ */
+prefix operator ~
+public prefix func ~ <T>(type: T.Type) -> AnyDynamicType {
+  return DynamicType(type)
+}

package/ios/Swift/DynamicTypes/DynamicTypedArrayType.swift

@@ -0,0 +1,46 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+internal struct DynamicTypedArrayType: AnyDynamicType {
+  let innerType: AnyTypedArray.Type
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    return innerType == InnerType.self
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    if let typedArrayType = type as? Self {
+      return typedArrayType.innerType == innerType
+    }
+    return false
+  }
+
+  func cast<ValueType>(_ value: ValueType) throws -> Any {
+    // It must be a JavaScript typed array.
+    guard let value = value as? JavaScriptValue, let jsTypedArray = value.getTypedArray() else {
+      throw NotTypedArrayException(innerType)
+    }
+    let typedArray = TypedArray.create(from: jsTypedArray)
+
+    // Concrete typed arrays must be the same as the inner type.
+    guard innerType == TypedArray.self || type(of: typedArray) == innerType else {
+      throw ArrayTypeMismatchException((received: type(of: typedArray), expected: innerType))
+    }
+    return typedArray
+  }
+
+  var description: String {
+    return String(describing: innerType)
+  }
+}
+
+internal final class ArrayTypeMismatchException: GenericException<(received: Any.Type, expected: Any.Type)> {
+  override var reason: String {
+    "Received a typed array of type \(param.received), expected \(param.expected)"
+  }
+}
+
+internal final class NotTypedArrayException: GenericException<AnyTypedArray.Type> {
+  override var reason: String {
+    "Given argument is not an instance of \(param)"
+  }
+}

package/ios/Swift/Exceptions/CodedError.swift

@@ -3,7 +3,7 @@ import Foundation
 /**
  A protocol for errors specyfing its `code` and providing the `description`.
  */
-public protocol CodedError: Error {
+public protocol CodedError: Error, CustomStringConvertible {
   var code: String { get }
   var description: String { get }
 }