expo-modules-core 0.9.2 → 0.10.0

package/ios/Swift/Objects/ObjectDefinitionComponents.swift

@@ -42,10 +42,11 @@ public func Constants(_ body: @autoclosure @escaping () -> [String: Any?]) -> An
 public func function<R>(
   _ name: String,
   _ closure: @escaping () throws -> R
-) -> AnyFunction {
-  return ConcreteFunction(
+) -> AsyncFunctionComponent<(), Void, R> {
+  return AsyncFunctionComponent(
     name,
-    argTypes: [],
+    firstArgType: Void.self,
+    dynamicArgumentTypes: [],
     closure
   )
 }
@@ -57,10 +58,11 @@ public func function<R>(
 public func function<R, A0: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0) throws -> R
-) -> AnyFunction {
-  return ConcreteFunction(
+) -> AsyncFunctionComponent<(A0), A0, R> {
+  return AsyncFunctionComponent(
     name,
-    argTypes: [ArgumentType(A0.self)],
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [~A0.self],
     closure
   )
 }
@@ -72,10 +74,11 @@ public func function<R, A0: AnyArgument>(
 public func function<R, A0: AnyArgument, A1: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1) throws -> R
-) -> AnyFunction {
-  return ConcreteFunction(
+) -> AsyncFunctionComponent<(A0, A1), A0, R> {
+  return AsyncFunctionComponent(
     name,
-    argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [~A0.self, ~A1.self],
     closure
   )
 }
@@ -87,13 +90,14 @@ public func function<R, A0: AnyArgument, A1: AnyArgument>(
 public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1, A2) throws -> R
-) -> AnyFunction {
-  return ConcreteFunction(
+) -> AsyncFunctionComponent<(A0, A1, A2), A0, R> {
+  return AsyncFunctionComponent(
     name,
-    argTypes: [
-      ArgumentType(A0.self),
-      ArgumentType(A1.self),
-      ArgumentType(A2.self)
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self
     ],
     closure
   )
@@ -106,14 +110,15 @@ public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
 public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1, A2, A3) throws -> R
-) -> AnyFunction {
-  return ConcreteFunction(
+) -> AsyncFunctionComponent<(A0, A1, A2, A3), A0, R> {
+  return AsyncFunctionComponent(
     name,
-    argTypes: [
-      ArgumentType(A0.self),
-      ArgumentType(A1.self),
-      ArgumentType(A2.self),
-      ArgumentType(A3.self)
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self
     ],
     closure
   )
@@ -126,15 +131,16 @@ public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: A
 public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1, A2, A3, A4) throws -> R
-) -> AnyFunction {
-  return ConcreteFunction(
+) -> AsyncFunctionComponent<(A0, A1, A2, A3, A4), A0, R> {
+  return AsyncFunctionComponent(
     name,
-    argTypes: [
-      ArgumentType(A0.self),
-      ArgumentType(A1.self),
-      ArgumentType(A2.self),
-      ArgumentType(A3.self),
-      ArgumentType(A4.self)
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self
     ],
     closure
   )
@@ -147,16 +153,17 @@ public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: A
 public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1, A2, A3, A4, A5) throws -> R
-) -> AnyFunction {
-  return ConcreteFunction(
+) -> AsyncFunctionComponent<(A0, A1, A2, A3, A4, A5), A0, R> {
+  return AsyncFunctionComponent(
     name,
-    argTypes: [
-      ArgumentType(A0.self),
-      ArgumentType(A1.self),
-      ArgumentType(A2.self),
-      ArgumentType(A3.self),
-      ArgumentType(A4.self),
-      ArgumentType(A5.self)
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self
     ],
     closure
   )
@@ -169,17 +176,18 @@ public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: A
 public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6) throws -> R
-) -> AnyFunction {
-  return ConcreteFunction(
+) -> AsyncFunctionComponent<(A0, A1, A2, A3, A4, A5, A6), A0, R> {
+  return AsyncFunctionComponent(
     name,
-    argTypes: [
-      ArgumentType(A0.self),
-      ArgumentType(A1.self),
-      ArgumentType(A2.self),
-      ArgumentType(A3.self),
-      ArgumentType(A4.self),
-      ArgumentType(A5.self),
-      ArgumentType(A6.self)
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self,
+      ~A6.self
     ],
     closure
   )
@@ -192,18 +200,19 @@ public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: A
 public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument, A7: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6, A7) throws -> R
-) -> AnyFunction {
-  return ConcreteFunction(
+) -> AsyncFunctionComponent<(A0, A1, A2, A3, A4, A5, A6, A7), A0, R> {
+  return AsyncFunctionComponent(
     name,
-    argTypes: [
-      ArgumentType(A0.self),
-      ArgumentType(A1.self),
-      ArgumentType(A2.self),
-      ArgumentType(A3.self),
-      ArgumentType(A4.self),
-      ArgumentType(A5.self),
-      ArgumentType(A6.self),
-      ArgumentType(A7.self)
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self,
+      ~A6.self,
+      ~A7.self
     ],
     closure
   )
@@ -230,28 +239,28 @@ public func Events(_ names: String...) -> AnyDefinition {
  Function that is invoked when the first event listener is added.
  */
 @available(*, deprecated, renamed: "OnStartObserving")
-public func onStartObserving(_ body: @escaping () -> Void) -> AnyFunction {
-  return ConcreteFunction("startObserving", argTypes: [], body)
+public func onStartObserving(_ body: @escaping () -> Void) -> AsyncFunctionComponent<(), Void, Void> {
+  return AsyncFunctionComponent("startObserving", firstArgType: Void.self, dynamicArgumentTypes: [], body)
 }
 
 /**
  Function that is invoked when the first event listener is added.
  */
-public func OnStartObserving(_ body: @escaping () -> Void) -> AnyFunction {
-  return ConcreteFunction("startObserving", argTypes: [], body)
+public func OnStartObserving(_ body: @escaping () -> Void) -> AsyncFunctionComponent<(), Void, Void> {
+  return AsyncFunctionComponent("startObserving", firstArgType: Void.self, dynamicArgumentTypes: [], body)
 }
 
 /**
  Function that is invoked when all event listeners are removed.
  */
 @available(*, deprecated, renamed: "OnStopObserving")
-public func onStopObserving(_ body: @escaping () -> Void) -> AnyFunction {
-  return ConcreteFunction("stopObserving", argTypes: [], body)
+public func onStopObserving(_ body: @escaping () -> Void) -> AsyncFunctionComponent<(), Void, Void> {
+  return AsyncFunctionComponent("stopObserving", firstArgType: Void.self, dynamicArgumentTypes: [], body)
 }
 
 /**
  Function that is invoked when all event listeners are removed.
  */
-public func OnStopObserving(_ body: @escaping () -> Void) -> AnyFunction {
-  return ConcreteFunction("stopObserving", argTypes: [], body)
+public func OnStopObserving(_ body: @escaping () -> Void) -> AsyncFunctionComponent<(), Void, Void> {
+  return AsyncFunctionComponent("stopObserving", firstArgType: Void.self, dynamicArgumentTypes: [], body)
 }

package/ios/Swift/Objects/PropertyComponent.swift

@@ -0,0 +1,147 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+public final class PropertyComponent: AnyDefinition {
+  /**
+   Name of the property.
+   */
+  let name: String
+
+  /**
+   Synchronous function that is called when the property is being accessed.
+   */
+  var getter: AnySyncFunctionComponent?
+
+  /**
+   Synchronous function that is called when the property is being set.
+   */
+  var setter: AnySyncFunctionComponent?
+
+  init(name: String) {
+    self.name = name
+  }
+
+  // MARK: - Modifiers
+
+  /**
+   Modifier that sets property getter that has no arguments (the caller is not used).
+   */
+  public func get<Value>(_ getter: @escaping () -> Value) -> Self {
+    self.getter = SyncFunctionComponent(
+      "get",
+      firstArgType: Void.self,
+      dynamicArgumentTypes: [~Any.self],
+      { (caller: Any) in getter() }
+    )
+    return self
+  }
+
+  /**
+   Modifier that sets property setter that receives only the new value as an argument.
+   */
+  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) }
+    )
+    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.
+   */
+  public func get<Value, Caller>(_ getter: @escaping (_ this: Caller) -> Value) -> Self {
+    self.getter = SyncFunctionComponent(
+      "get",
+      firstArgType: Caller.self,
+      dynamicArgumentTypes: [~Caller.self],
+      getter
+    )
+    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.
+   */
+  public func set<Value, Caller>(_ setter: @escaping (_ this: Caller, _ newValue: Value) -> ()) -> Self {
+    self.setter = SyncFunctionComponent(
+      "set",
+      firstArgType: Caller.self,
+      dynamicArgumentTypes: [~Caller.self, ~Value.self],
+      setter
+    )
+    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 setValue(_ value: Any, caller: AnyObject? = nil) {
+    let _ = try? setter?.call(by: caller, withArguments: [caller as Any, 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)
+    }
+  }
+
+  /**
+   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)
+    }
+  }
+
+  /**
+   Creates the JavaScript object representing the property descriptor.
+   */
+  internal func buildDescriptor(inRuntime runtime: JavaScriptRuntime, withCaller caller: AnyObject?) -> JavaScriptObject {
+    let descriptor = runtime.createObject()
+
+    descriptor.setProperty("enumerable", value: true)
+
+    if getter != nil {
+      descriptor.setProperty("get", value: buildGetter(inRuntime: runtime, withCaller: caller))
+    }
+    if setter != nil {
+      descriptor.setProperty("set", value: buildSetter(inRuntime: runtime, withCaller: caller))
+    }
+    return descriptor
+  }
+}
+
+// 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 {
+  return PropertyComponent(name: name)
+}
+
+/**
+ Creates the read-only property whose getter doesn't take the caller as an argument.
+ */
+public func Property<Value: AnyArgument>(_ name: String, get: @escaping () -> Value) -> PropertyComponent {
+  return PropertyComponent(name: name).get(get)
+}
+
+/**
+ Creates the read-only property whose getter takes the caller as an argument.
+ */
+public func Property<Value: AnyArgument, Caller>(_ name: String, get: @escaping (Caller) -> Value) -> PropertyComponent {
+  return PropertyComponent(name: name).get(get)
+}

package/ios/Swift/Promise.swift

@@ -2,7 +2,7 @@
 
 public struct Promise: AnyArgument {
   public typealias ResolveClosure = (Any?) -> Void
-  public typealias RejectClosure = (CodedError) -> Void
+  public typealias RejectClosure = (Exception) -> Void
 
   public var resolver: ResolveClosure
   public var rejecter: RejectClosure
@@ -25,11 +25,20 @@ public struct Promise: AnyArgument {
     rejecter(UnexpectedException(error))
   }
 
-  public func reject(_ error: CodedError) {
+  public func reject(_ error: Exception) {
     rejecter(error)
   }
 
   public func reject(_ code: String, _ description: String) {
-    rejecter(SimpleCodedError(code, description))
+    rejecter(Exception(name: code, description: description))
+  }
+
+  public func settle<ValueType, ExceptionType: Exception>(with result: Result<ValueType, ExceptionType>) {
+    switch result {
+    case .success(let value):
+      resolve(value)
+    case .failure(let exception):
+      reject(exception)
+    }
   }
 }

package/ios/Swift/Records/Field.swift

@@ -8,7 +8,7 @@ public final class Field<Type>: AnyFieldInternal {
    */
   public var wrappedValue: Type
 
-  private let fieldType: AnyArgumentType = ArgumentType(Type.self)
+  private let fieldType: AnyDynamicType = ~Type.self
 
   /**
    Field's key in the dictionary, which by default is a label of the wrapped property.
@@ -27,7 +27,7 @@ public final class Field<Type>: AnyFieldInternal {
    Whether the generic field type accepts `nil` values.
    */
   internal var isOptional: Bool {
-    return fieldType is OptionalArgumentType
+    return fieldType is DynamicOptionalType
   }
 
   internal var isRequired: Bool {

package/ios/Swift/SharedObjects/SharedObject.swift

@@ -0,0 +1,20 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+public protocol AnySharedObject: AnyArgument {
+  var sharedObjectId: SharedObjectId { get }
+}
+
+open class SharedObject: AnySharedObject {
+  /**
+   An identifier of the native shared object that maps to the JavaScript object.
+   When the object is not linked with any JavaScript object, its value is 0.
+   */
+  public internal(set) var sharedObjectId: SharedObjectId = 0
+
+  /**
+   Returns the JavaScript shared object associated with the native shared object.
+   */
+  public func getJavaScriptObject() -> JavaScriptObject? {
+    return SharedObjectRegistry.toJavaScriptObject(self)
+  }
+}

package/ios/Swift/SharedObjects/SharedObjectRegistry.swift

@@ -0,0 +1,129 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Type of the IDs of shared objects.
+ */
+public typealias SharedObjectId = Int
+
+/**
+ A tuple containing a pair of matching native and JS objects.
+ */
+internal typealias SharedObjectPair = (native: SharedObject, javaScript: JavaScriptWeakObject)
+
+/**
+ Property name of the JS object where the shared object ID is stored.
+ */
+let sharedObjectIdPropertyName = "__expo_shared_object_id__"
+
+/**
+ The registry of all shared objects used in the entire app.
+ It's been made static for simplicity.
+ */
+public final class SharedObjectRegistry {
+  /**
+   The counter of IDs to assign to the shared object pairs.
+   The next pair added to the registry will be saved using this ID.
+   */
+  internal static var nextId: SharedObjectId = 1
+
+  /**
+   A dictionary of shared object pairs.
+   */
+  internal static var pairs = [SharedObjectId: SharedObjectPair]()
+
+  /**
+   A number of all pairs stored in the registry.
+   */
+  internal static var size: Int {
+    return pairs.count
+  }
+
+  /**
+   Returns the next shared object ID and increases the counter.
+   */
+  @discardableResult
+  internal static func pullNextId() -> SharedObjectId {
+    let id = nextId
+    nextId += 1
+    return id
+  }
+
+  /**
+   Returns a pair of shared objects with given ID or `nil` when there is no such pair in the registry.
+   */
+  internal static func get(_ id: SharedObjectId) -> SharedObjectPair? {
+    return pairs[id]
+  }
+
+  /**
+   Adds a pair of native and JS shared object to the registry. Assigns a new shared object ID to these objects.
+   */
+  @discardableResult
+  internal static func add(native nativeObject: SharedObject, javaScript jsObject: JavaScriptObject) -> SharedObjectId {
+    let id = pullNextId()
+
+    // Assigns the ID to the objects.
+    nativeObject.sharedObjectId = id
+    jsObject.defineProperty(sharedObjectIdPropertyName, value: id, options: [.writable])
+
+    // Set the deallocator on the JS object that deletes the entire pair.
+    jsObject.setObjectDeallocator { delete(id) }
+
+    // Save the pair in the dictionary.
+    pairs[id] = (native: nativeObject, javaScript: jsObject.createWeak())
+
+    return id
+  }
+
+  /**
+   Deletes the shared objects pair with a given ID.
+   */
+  internal static func delete(_ id: SharedObjectId) {
+    if let pair = pairs[id] {
+      // Reset an ID on the objects.
+      pair.native.sharedObjectId = 0
+      pair.javaScript.lock()?.defineProperty(sharedObjectIdPropertyName, value: 0, options: [.writable])
+
+      // Delete the pair from the dictionary.
+      pairs[id] = nil
+    }
+  }
+
+  /**
+   Gets the native shared object that is paired with a given JS object.
+   */
+  internal static func toNativeObject(_ jsObject: JavaScriptObject) -> SharedObject? {
+    if let objectId = try? jsObject.getProperty(sharedObjectIdPropertyName).asInt() {
+      return pairs[objectId]?.native
+    }
+    return nil
+  }
+
+  /**
+   Gets the JS shared object that is paired with a given native object.
+   */
+  internal static func toJavaScriptObject(_ nativeObject: SharedObject) -> JavaScriptObject? {
+    let objectId = nativeObject.sharedObjectId
+    return pairs[objectId]?.javaScript.lock()
+  }
+
+  /**
+   Creates a plain JS object and pairs it with a given native object.
+   */
+  internal static func createSharedJavaScriptObject(runtime: JavaScriptRuntime, nativeObject: SharedObject) -> JavaScriptObject {
+    let object = runtime.createObject()
+    add(native: nativeObject, javaScript: object)
+    return object
+  }
+
+  /**
+   Ensures that there is a JS object paired with a given native object. If not, a plain JS object is created.
+   */
+  internal static func ensureSharedJavaScriptObject(runtime: JavaScriptRuntime, nativeObject: SharedObject) -> JavaScriptObject {
+    if let jsObject = toJavaScriptObject(nativeObject) {
+      // JS object for this native object already exists in the registry, just return it.
+      return jsObject
+    }
+    return createSharedJavaScriptObject(runtime: runtime, nativeObject: nativeObject)
+  }
+}

package/ios/Swift/TypedArrays/AnyTypedArray.swift

@@ -0,0 +1,11 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ A protocol for all typed arrays.
+ */
+internal protocol AnyTypedArray: AnyArgument {
+  /**
+   Initializes a typed array from the given JavaScript representation.
+   */
+  init(_ jsTypedArray: JavaScriptTypedArray)
+}

package/ios/Swift/TypedArrays/ConcreteTypedArrays.swift

@@ -0,0 +1,56 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Native equivalent of `Int8Array` in JavaScript, an array of two's-complement 8-bit signed integers.
+ */
+public final class Int8Array: GenericTypedArray<Int8> {}
+
+/**
+ Native equivalent of `Int16Array` in JavaScript, an array of two's-complement 16-bit signed integers.
+ */
+public final class Int16Array: GenericTypedArray<Int16> {}
+
+/**
+ Native equivalent of `Int32Array` in JavaScript, an array of two's-complement 32-bit signed integers.
+ */
+public final class Int32Array: GenericTypedArray<Int32> {}
+
+/**
+ Native equivalent of `Uint8Array` in JavaScript, an array of 8-bit unsigned integers.
+ */
+public final class Uint8Array: GenericTypedArray<UInt8> {}
+
+/**
+ Native equivalent of `Uint8ClampedArray` in JavaScript, an array of 8-bit unsigned integers clamped to 0-255.
+ */
+public final class Uint8ClampedArray: GenericTypedArray<UInt8> {}
+
+/**
+ Native equivalent of `Uint16Array` in JavaScript, an array of 16-bit unsigned integers.
+ */
+public final class Uint16Array: GenericTypedArray<UInt16> {}
+
+/**
+ Native equivalent of `Uint32Array` in JavaScript, an array of 32-bit unsigned integers.
+ */
+public final class Uint32Array: GenericTypedArray<UInt32> {}
+
+/**
+ Native equivalent of `Float32Array` in JavaScript, an array of 32-bit floating point numbers.
+ */
+public final class Float32Array: GenericTypedArray<Float32> {}
+
+/**
+ Native equivalent of `Float64Array` in JavaScript, an array of 64-bit floating point numbers.
+ */
+public final class Float64Array: GenericTypedArray<Float64> {}
+
+/**
+ Native equivalent of `BigInt64Array` in JavaScript, an array of 64-bit signed integers.
+ */
+public final class BigInt64Array: GenericTypedArray<Int64> {}
+
+/**
+ Native equivalent of `BigUint64Array` in JavaScript, an array of 64-bit unsigned integers.
+ */
+public final class BigUint64Array: GenericTypedArray<UInt64> {}