expo-modules-core 1.0.4 → 1.1.0

package/ios/ReactDelegates/ExpoReactDelegate.swift

@@ -22,10 +22,15 @@ public class ExpoReactDelegate: NSObject {
   }
 
   @objc
-  public func createRootView(bridge: RCTBridge, moduleName: String, initialProperties: [AnyHashable: Any]?) -> UIView {
+  public func createRootView(
+    bridge: RCTBridge,
+    moduleName: String,
+    initialProperties: [AnyHashable: Any]?,
+    fabricEnabled: Bool = EXAppDefines.APP_NEW_ARCH_ENABLED
+  ) -> UIView {
     return self.handlers.lazy
       .compactMap { $0.createRootView(reactDelegate: self, bridge: bridge, moduleName: moduleName, initialProperties: initialProperties) }
-      .first(where: { _ in true }) ?? EXAppSetupDefaultRootView(bridge, moduleName, initialProperties)
+      .first(where: { _ in true }) ?? EXAppSetupDefaultRootView(bridge, moduleName, initialProperties, fabricEnabled)
   }
 
   @objc

package/ios/Swift/AppContext.swift

@@ -91,6 +91,15 @@ public final class AppContext: NSObject {
     return view as? ViewType
   }
 
+  // MARK: - Running on specific queues
+
+  /**
+   Runs a code block on the JavaScript thread.
+   */
+  public func executeOnJavaScriptThread(runBlock: @escaping (() -> Void)) {
+    reactBridge?.dispatchBlock(runBlock, queue: RCTJSThread)
+  }
+
   // MARK: - Legacy modules
 
   /**

package/ios/Swift/Arguments/Enumerable.swift

@@ -3,7 +3,7 @@
 /**
  A protocol that allows converting raw values to enum cases.
  */
-public protocol Enumerable: AnyArgument {
+public protocol Enumerable: AnyArgument, CaseIterable {
   /**
    Tries to create an enum case using given raw value.
    May throw errors, e.g. when the raw value doesn't match any case.
@@ -44,21 +44,7 @@ public extension Enumerable where Self: RawRepresentable, Self: Hashable {
   }
 
   static var allRawValues: [Any] {
-    // Be careful — it operates on unsafe pointers!
-    let sequence = AnySequence { () -> AnyIterator<RawValue> in
-      var raw = 0
-      return AnyIterator {
-        let current: Self? = withUnsafePointer(to: &raw) { ptr in
-          ptr.withMemoryRebound(to: Self.self, capacity: 1) { $0.pointee }
-        }
-        guard let value = current?.rawValue else {
-          return nil
-        }
-        raw += 1
-        return value
-      }
-    }
-    return Array(sequence)
+    return allCases.map { $0.rawValue }
   }
 }
 

package/ios/Swift/Classes/ClassComponentElement.swift

@@ -25,7 +25,7 @@ extension AsyncFunctionComponent: ClassComponentElement {
 }
 
 extension PropertyComponent: ClassComponentElement {
-  public typealias OwnerType = Void
+  // It already has the `OwnerType`
 }
 
 extension ConstantsDefinition: ClassComponentElement {

package/ios/Swift/Convertibles/Either.swift

@@ -51,8 +51,11 @@ open class Either<FirstType, SecondType>: Convertible {
   // MARK: - Convertible
 
   public class func convert(from value: Any?) throws -> Self {
-    if value is FirstType || value is SecondType {
-      return Self(value)
+    for type in dynamicTypes() {
+      // Initialize the "either" when the current type can cast given value.
+      if let value = try? type.cast(value) {
+        return Self(value)
+      }
     }
     throw NeitherTypeException(Self.dynamicTypes())
   }
@@ -79,12 +82,6 @@ open class EitherOfThree<FirstType, SecondType, ThirdType>: Either<FirstType, Se
   public func get() -> ThirdType? {
     return value as? ThirdType
   }
-
-  // MARK: - Convertible
-
-  public override class func convert(from value: Any?) throws -> Self {
-    return value is ThirdType ? Self(value) : try super.convert(from: value)
-  }
 }
 
 /*
@@ -108,12 +105,6 @@ open class EitherOfFour<FirstType, SecondType, ThirdType, FourthType>: EitherOfT
   public func get() -> FourthType? {
     return value as? FourthType
   }
-
-  // MARK: - Convertible
-
-  public override class func convert(from value: Any?) throws -> Self {
-    return value is FourthType ? Self(value) : try super.convert(from: value)
-  }
 }
 
 // MARK: - Exceptions

package/ios/Swift/DynamicTypes/DynamicEnumType.swift

@@ -4,7 +4,7 @@
  A dynamic type representing an enum that conforms to `Enumerable`.
  */
 internal struct DynamicEnumType: AnyDynamicType {
-  let innerType: Enumerable.Type
+  let innerType: any Enumerable.Type
 
   func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
     return innerType == InnerType.self

package/ios/Swift/DynamicTypes/DynamicSharedObjectType.swift

@@ -18,6 +18,10 @@ internal struct DynamicSharedObjectType: AnyDynamicType {
   }
 
   func cast<ValueType>(_ value: ValueType) throws -> Any {
+    if let value = value as? SharedObject, type(of: value) == innerType {
+      // Given value is a shared object already
+      return value
+    }
     if let jsObject = try (value as? JavaScriptValue)?.asObject(),
        let nativeSharedObject = SharedObjectRegistry.toNativeObject(jsObject) {
       return nativeSharedObject

package/ios/Swift/DynamicTypes/DynamicType.swift

@@ -18,7 +18,7 @@ internal func DynamicType<T>(_ type: T.Type) -> AnyDynamicType {
   if let ConvertibleType = T.self as? Convertible.Type {
     return DynamicConvertibleType(innerType: ConvertibleType)
   }
-  if let EnumType = T.self as? Enumerable.Type {
+  if let EnumType = T.self as? any Enumerable.Type {
     return DynamicEnumType(innerType: EnumType)
   }
   if let SharedObjectType = T.self as? SharedObject.Type {

package/ios/Swift/Functions/AnyFunction.swift

@@ -23,6 +23,11 @@ internal protocol AnyFunction: AnyDefinition, JavaScriptObjectBuilder {
    */
   var argumentsCount: Int { get }
 
+  /**
+   A minimum number of arguments the functions needs which equals to `argumentsCount` reduced by the number of trailing optional arguments.
+   */
+  var requiredArgumentsCount: Int { get }
+
   /**
    Indicates whether the function's arguments starts from the owner that calls this function.
    */
@@ -42,6 +47,19 @@ internal protocol AnyFunction: AnyDefinition, JavaScriptObjectBuilder {
 }
 
 extension AnyFunction {
+  var requiredArgumentsCount: Int {
+    var trailingOptionalArgumentsCount: Int = 0
+
+    for dynamicArgumentType in dynamicArgumentTypes.reversed() {
+      if dynamicArgumentType is DynamicOptionalType {
+        trailingOptionalArgumentsCount += 1
+      } else {
+        break
+      }
+    }
+    return argumentsCount - trailingOptionalArgumentsCount
+  }
+
   /**
    Calls the function just like `call(by:withArguments:callback:)`, but without an owner
    and with an empty callback. Might be useful when you only want to call the function,

package/ios/Swift/JavaScriptUtils.swift

@@ -28,10 +28,16 @@ internal func cast(_ value: Any, toType type: AnyDynamicType) throws -> Any {
  of function's arguments (without an owner and promise). Rethrows exceptions thrown by `cast(_:toType:)`.
  */
 internal func cast(arguments: [Any], forFunction function: AnyFunction) throws -> [Any] {
-  if arguments.count != function.argumentsCount {
-    throw InvalidArgsNumberException((received: arguments.count, expected: function.argumentsCount))
-  }
+  let requiredArgumentsCount = function.requiredArgumentsCount
   let argumentTypeOffset = function.takesOwner ? 1 : 0
+
+  if arguments.count < requiredArgumentsCount || arguments.count > function.argumentsCount {
+    throw InvalidArgsNumberException((
+      received: arguments.count,
+      expected: function.argumentsCount,
+      required: requiredArgumentsCount
+    ))
+  }
   return try arguments.enumerated().map { index, argument in
     let argumentType = function.dynamicArgumentTypes[index + argumentTypeOffset]
 
@@ -44,20 +50,31 @@ internal func cast(arguments: [Any], forFunction function: AnyFunction) throws -
 }
 
 /**
- Prepends the owner to the array of arguments if the given function can take it.
+ Ensures the provided array of arguments matches the number of arguments expected by the function.
+ - If the function takes the owner, it's added to the beginning.
+ - If the array is still too small, missing arguments are very likely to be optional so it puts `nil` in their place.
  */
 internal func concat(arguments: [Any], withOwner owner: AnyObject?, forFunction function: AnyFunction) -> [Any] {
+  var result = arguments
+
   if function.takesOwner, let owner = try? function.dynamicArgumentTypes.first?.cast(owner) {
-    return [owner] + arguments
+    result = [owner] + arguments
+  }
+  if arguments.count < function.argumentsCount {
+    result += Array(repeating: Any?.none as Any, count: function.argumentsCount - arguments.count)
   }
-  return arguments
+  return result
 }
 
 // MARK: - Exceptions
 
-internal class InvalidArgsNumberException: GenericException<(received: Int, expected: Int)> {
+internal class InvalidArgsNumberException: GenericException<(received: Int, expected: Int, required: Int)> {
   override var reason: String {
-    "Received \(param.received) arguments, but \(param.expected) was expected"
+    if param.required < param.expected {
+      return "Received \(param.received) arguments, but \(param.expected) was expected and at least \(param.required) is required"
+    } else {
+      return "Received \(param.received) arguments, but \(param.expected) was expected"
+    }
   }
 }
 

package/ios/Swift/Objects/ObjectDefinition.swift

@@ -17,7 +17,7 @@ public class ObjectDefinition: AnyDefinition, JavaScriptObjectBuilder {
   /**
    A map of dynamic properties defined by the object.
    */
-  let properties: [String: PropertyComponent]
+  let properties: [String: AnyPropertyComponent]
 
   /**
    A map of classes defined within the object.
@@ -38,8 +38,8 @@ public class ObjectDefinition: AnyDefinition, JavaScriptObjectBuilder {
       .compactMap { $0 as? ConstantsDefinition }
 
     self.properties = definitions
-      .compactMap { $0 as? PropertyComponent }
-      .reduce(into: [String: PropertyComponent]()) { dict, property in
+      .compactMap { $0 as? AnyPropertyComponent }
+      .reduce(into: [String: AnyPropertyComponent]()) { dict, property in
         dict[property.name] = property
       }
 
@@ -90,7 +90,7 @@ public class ObjectDefinition: AnyDefinition, JavaScriptObjectBuilder {
 
   internal func decorateWithProperties(runtime: JavaScriptRuntime, object: JavaScriptObject) {
     for property in properties.values {
-      let descriptor = property.buildDescriptor(inRuntime: runtime, withCaller: object)
+      let descriptor = property.buildDescriptor(inRuntime: runtime)
       object.defineProperty(property.name, descriptor: descriptor)
     }
   }

package/ios/Swift/Objects/ObjectDefinitionComponents.swift

@@ -26,6 +26,13 @@ public func Events(_ names: String...) -> EventsDefinition {
   return EventsDefinition(names: names)
 }
 
+/**
+ Defines event names that the object can send to JavaScript.
+ */
+public func Events(_ names: [String]) -> EventsDefinition {
+  return EventsDefinition(names: names)
+}
+
 /**
  Function that is invoked when the first event listener is added.
  */

package/ios/Swift/Objects/PropertyComponent.swift

@@ -1,6 +1,18 @@
 // Copyright 2022-present 650 Industries. All rights reserved.
 
-public final class PropertyComponent: AnyDefinition {
+protocol AnyPropertyComponent {
+  /**
+   Name of the property.
+   */
+  var name: String { get }
+
+  /**
+   Creates the JavaScript object representing the property descriptor.
+   */
+  func buildDescriptor(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject
+}
+
+public final class PropertyComponent<OwnerType>: AnyDefinition, AnyPropertyComponent {
   /**
    Name of the property.
    */
@@ -16,135 +28,213 @@ public final class PropertyComponent: AnyDefinition {
    */
   var setter: AnySyncFunctionComponent?
 
+  /**
+   Initializes an unowned PropertyComponent without getter and setter functions.
+   */
   init(name: String) {
     self.name = name
   }
 
+  /**
+   Initializes an unowned PropertyComponent with a getter without arguments.
+   */
+  init<ReturnType>(name: String, getter: @escaping () -> ReturnType) {
+    self.name = name
+
+    // Set the getter right away
+    self.get(getter)
+  }
+
+  /**
+   Initializes an owned PropertyComponent with a getter that takes the owner as its first argument.
+   */
+  init<ReturnType>(name: String, getter: @escaping (_ this: OwnerType) -> ReturnType) {
+    self.name = name
+
+    // Set the getter right away
+    self.get(getter)
+  }
+
   // MARK: - Modifiers
 
   /**
-   Modifier that sets property getter that has no arguments (the caller is not used).
+   Modifier that sets property getter that has no arguments (the owner is not used).
    */
-  public func get<Value>(_ getter: @escaping () -> Value) -> Self {
+  @discardableResult
+  public func get<ReturnType>(_ getter: @escaping () -> ReturnType) -> Self {
     self.getter = SyncFunctionComponent(
       "get",
       firstArgType: Void.self,
-      dynamicArgumentTypes: [~Any.self],
-      { (caller: Any) in getter() }
+      dynamicArgumentTypes: [],
+      getter
     )
     return self
   }
 
   /**
-   Modifier that sets property setter that receives only the new value as an argument.
+   Modifier that sets property getter that receives the owner as an argument.
+   The owner is an object on which the function is called, like `this` in JavaScript.
    */
-  public func set<Value>(_ setter: @escaping (_ newValue: Value) -> ()) -> Self {
-    self.setter = SyncFunctionComponent(
-      "set",
-      firstArgType: Void.self,
-      dynamicArgumentTypes: [~Any.self, ~Value.self],
-      { (caller: Any, value: Value) in setter(value) }
+  @discardableResult
+  public func get<ReturnType>(_ getter: @escaping (_ this: OwnerType) -> ReturnType) -> Self {
+    self.getter = SyncFunctionComponent(
+      "get",
+      firstArgType: OwnerType.self,
+      dynamicArgumentTypes: [~OwnerType.self],
+      getter
     )
+    self.getter?.takesOwner = true
     return self
   }
 
   /**
-   Modifier that sets property getter that receives the caller as an argument.
-   The caller is an object on which the function is called, like `this` in JavaScript.
+   Modifier that sets property setter that receives only the new value as an argument.
    */
-  public func get<Value, Caller>(_ getter: @escaping (_ this: Caller) -> Value) -> Self {
-    self.getter = SyncFunctionComponent(
-      "get",
-      firstArgType: Caller.self,
-      dynamicArgumentTypes: [~Caller.self],
-      getter
+  @discardableResult
+  public func set<ValueType>(_ setter: @escaping (_ newValue: ValueType) -> Void) -> Self {
+    self.setter = SyncFunctionComponent(
+      "set",
+      firstArgType: ValueType.self,
+      dynamicArgumentTypes: [~ValueType.self],
+      setter
     )
     return self
   }
 
   /**
-   Modifier that sets property setter that receives the caller and the new value as arguments.
-   The caller is an object on which the function is called, like `this` in JavaScript.
+   Modifier that sets property setter that receives the owner and the new value as arguments.
+   The owner is an object on which the function is called, like `this` in JavaScript.
    */
-  public func set<Value, Caller>(_ setter: @escaping (_ this: Caller, _ newValue: Value) -> ()) -> Self {
+  @discardableResult
+  public func set<ValueType>(_ setter: @escaping (_ this: OwnerType, _ newValue: ValueType) -> Void) -> Self {
     self.setter = SyncFunctionComponent(
       "set",
-      firstArgType: Caller.self,
-      dynamicArgumentTypes: [~Caller.self, ~Value.self],
+      firstArgType: OwnerType.self,
+      dynamicArgumentTypes: [~OwnerType.self, ~ValueType.self],
       setter
     )
+    self.setter?.takesOwner = true
     return self
   }
 
   // MARK: - Internals
 
-  internal func getValue<Value>(caller: AnyObject? = nil) -> Value? {
-    let value = try? getter?.call(by: caller, withArguments: [caller as Any])
-    return value as? Value
+  internal func getValue<ValueType>(owner: OwnerType? = nil) throws -> ValueType? {
+    let owner = owner as? AnyObject
+    let value = try getter?.call(by: owner, withArguments: [])
+    return value as? ValueType
   }
 
-  internal func setValue(_ value: Any, caller: AnyObject? = nil) {
-    let _ = try? setter?.call(by: caller, withArguments: [caller as Any, value])
+  internal func setValue(_ value: Any, owner: OwnerType? = nil) {
+    let owner = owner as? AnyObject
+    _ = try? setter?.call(by: owner, withArguments: [value])
   }
 
   /**
    Creates the JavaScript function that will be used as a getter of the property.
    */
-  internal func buildGetter(inRuntime runtime: JavaScriptRuntime, withCaller caller: AnyObject?) -> JavaScriptObject {
-    return runtime.createSyncFunction(name, argsCount: 0) { [weak self, weak caller] this, args in
-      return self?.getValue(caller: caller)
+  internal func buildGetter(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
+    return runtime.createSyncFunction(name, argsCount: 0) { [weak self, name] this, args in
+      guard let self = self else {
+        throw NativePropertyUnavailableException(name)
+      }
+      guard let getter = self.getter else {
+        return
+      }
+      return try getter.call(by: this, withArguments: args)
     }
   }
 
   /**
    Creates the JavaScript function that will be used as a setter of the property.
    */
-  internal func buildSetter(inRuntime runtime: JavaScriptRuntime, withCaller caller: AnyObject?) -> JavaScriptObject {
-    return runtime.createSyncFunction(name, argsCount: 1) { [weak self, weak caller] this, args in
-      return self?.setValue(args.first as Any, caller: caller)
+  internal func buildSetter(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
+    return runtime.createSyncFunction(name, argsCount: 1) { [weak self, name] this, args in
+      guard let self = self else {
+        throw NativePropertyUnavailableException(name)
+      }
+      guard let setter = self.setter else {
+        return
+      }
+      return try setter.call(by: this, withArguments: args)
     }
   }
 
   /**
    Creates the JavaScript object representing the property descriptor.
    */
-  internal func buildDescriptor(inRuntime runtime: JavaScriptRuntime, withCaller caller: AnyObject?) -> JavaScriptObject {
+  internal func buildDescriptor(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
     let descriptor = runtime.createObject()
 
     descriptor.setProperty("enumerable", value: true)
 
     if getter != nil {
-      descriptor.setProperty("get", value: buildGetter(inRuntime: runtime, withCaller: caller))
+      descriptor.setProperty("get", value: buildGetter(inRuntime: runtime))
     }
     if setter != nil {
-      descriptor.setProperty("set", value: buildSetter(inRuntime: runtime, withCaller: caller))
+      descriptor.setProperty("set", value: buildSetter(inRuntime: runtime))
     }
     return descriptor
   }
 }
 
+// MARK: - Exceptions
+
+internal final class NativePropertyUnavailableException: GenericException<String> {
+  override var reason: String {
+    return "Native property '\(param)' is no longer available in memory"
+  }
+}
+
 // MARK: - Factory functions
 
 /**
  Creates the property with given name. The component is basically no-op if you don't call `.get(_:)` or `.set(_:)` on it.
  */
-public func Property(_ name: String) -> PropertyComponent {
+public func Property(_ name: String) -> PropertyComponent<Void> {
   return PropertyComponent(name: name)
 }
 
 /**
- Creates the read-only property whose getter doesn't take the caller as an argument.
+ Creates the read-only property whose getter doesn't take the owner as an argument.
  */
-public func Property<Value: AnyArgument>(_ name: String, @_implicitSelfCapture get: @escaping () -> Value) -> PropertyComponent {
-  return PropertyComponent(name: name).get(get)
+public func Property<Value: AnyArgument>(_ name: String, @_implicitSelfCapture get: @escaping () -> Value) -> PropertyComponent<Void> {
+  return PropertyComponent(name: name, getter: get)
 }
 
 /**
- Creates the read-only property whose getter takes the caller as an argument.
+ Creates the read-only property whose getter takes the owner as an argument.
  */
-public func Property<Value: AnyArgument, Caller>(
+public func Property<Value: AnyArgument, OwnerType>(
   _ name: String,
-  @_implicitSelfCapture get: @escaping (Caller) -> Value
-) -> PropertyComponent {
-  return PropertyComponent(name: name).get(get)
+  @_implicitSelfCapture get: @escaping (_ this: OwnerType) -> Value
+) -> PropertyComponent<OwnerType> {
+  return PropertyComponent<OwnerType>(name: name, getter: get)
+}
+
+/**
+ Creates the property that references to an immutable property of the owner object using the key path.
+ */
+public func Property<Value: AnyArgument, OwnerType>(
+  _ name: String,
+  _ keyPath: KeyPath<OwnerType, Value>
+) -> PropertyComponent<OwnerType> {
+  return PropertyComponent<OwnerType>(name: name) { owner in
+    return owner[keyPath: keyPath]
+  }
+}
+
+/**
+ Creates the property that references to a mutable property of the owner object using the key path.
+ */
+public func Property<Value: AnyArgument, OwnerType>(
+  _ name: String,
+  _ keyPath: ReferenceWritableKeyPath<OwnerType, Value>
+) -> PropertyComponent<OwnerType> {
+  return PropertyComponent<OwnerType>(name: name) { owner in
+    return owner[keyPath: keyPath]
+  }
+  .set { owner, newValue in
+    owner[keyPath: keyPath] = newValue
+  }
 }

package/ios/Swift/SharedObjects/SharedObject.swift

@@ -11,6 +11,11 @@ open class SharedObject: AnySharedObject {
    */
   public internal(set) var sharedObjectId: SharedObjectId = 0
 
+  /**
+   The default public initializer of the shared object.
+   */
+  public init() {}
+
   /**
    Returns the JavaScript shared object associated with the native shared object.
    */

package/ios/Tests/ClassComponentSpec.swift

@@ -169,6 +169,17 @@ class ClassComponentSpec: ExpoSpec {
         expect(newValue.kind) == .number
         expect(newValue.getInt()) == value + incrementBy
       }
+
+      it("gets value from the dynamic property") {
+        let initialValue = Int.random(in: 1..<100)
+        let value = try runtime!.eval([
+          "object = new expo.modules.TestModule.Counter(\(initialValue))",
+          "object.currentValue"
+        ])
+
+        expect(value.kind) == .number
+        expect(value.getInt()) == initialValue
+      }
     }
   }
 }
@@ -190,6 +201,10 @@ fileprivate final class ModuleWithCounterClass: Module {
       Function("getValue") { counter in
         return counter.currentValue
       }
+
+      Property("currentValue") { counter in
+        return counter.currentValue
+      }
     }
   }
 }

package/ios/Tests/EitherSpec.swift

@@ -40,6 +40,34 @@ final class EitherSpec: ExpoSpec {
       it("throws when converting from neither type") {
         expect({ try Either<String, Int>.convert(from: true) }).to(throwError(errorType: NeitherTypeException.self))
       }
+
+      it("supports arrays") {
+        let either = try Either<String, [String]>.convert(from: ["foo"])
+        let value: [String]? = either.get()
+
+        expect(either.is([String].self)) == true
+        expect(value) == ["foo"]
+      }
+
+      it("supports convertibles (UIColor)") {
+        let either = try Either<Int, UIColor>.convert(from: "blue")
+        let color: UIColor? = either.get()
+
+        expect(either.is(UIColor.self)) == true
+        expect(color?.cgColor.components) == CGColor(red: 0, green: 0, blue: 1, alpha: 1).components
+      }
+
+      it("supports records") {
+        struct TestRecord: Record {
+          @Field
+          var foo: String
+        }
+        let either = try Either<String, TestRecord>.convert(from: ["foo": "bar"])
+        let record: TestRecord? = either.get()
+
+        expect(either.is(TestRecord.self)) == true
+        expect(record?.foo) == "bar"
+      }
     }
     describe("EitherOfThree") {
       it("is the third type") {