expo-modules-core 0.7.0 → 0.8.0

package/ios/Swift/Objects/ObjectDefinitionComponents.swift

@@ -22,6 +22,7 @@ public func constants(_ body: @autoclosure @escaping () -> [String: Any?]) -> An
 /**
  Function without arguments.
  */
+@available(*, deprecated, renamed: "asyncFunction")
 public func function<R>(
   _ name: String,
   _ closure: @escaping () throws -> R
@@ -36,6 +37,7 @@ public func function<R>(
 /**
  Function with one argument.
  */
+@available(*, deprecated, renamed: "asyncFunction")
 public func function<R, A0: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0) throws -> R
@@ -50,6 +52,7 @@ public func function<R, A0: AnyArgument>(
 /**
  Function with two arguments.
  */
+@available(*, deprecated, renamed: "asyncFunction")
 public func function<R, A0: AnyArgument, A1: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1) throws -> R
@@ -64,6 +67,7 @@ public func function<R, A0: AnyArgument, A1: AnyArgument>(
 /**
  Function with three arguments.
  */
+@available(*, deprecated, renamed: "asyncFunction")
 public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1, A2) throws -> R
@@ -82,6 +86,7 @@ public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
 /**
  Function with four arguments.
  */
+@available(*, deprecated, renamed: "asyncFunction")
 public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1, A2, A3) throws -> R
@@ -101,6 +106,7 @@ public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: A
 /**
  Function with five arguments.
  */
+@available(*, deprecated, renamed: "asyncFunction")
 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
@@ -121,6 +127,7 @@ public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: A
 /**
  Function with six arguments.
  */
+@available(*, deprecated, renamed: "asyncFunction")
 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
@@ -142,6 +149,7 @@ public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: A
 /**
  Function with seven arguments.
  */
+@available(*, deprecated, renamed: "asyncFunction")
 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
@@ -164,6 +172,7 @@ public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: A
 /**
  Function with eight arguments.
  */
+@available(*, deprecated, renamed: "asyncFunction")
 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
@@ -184,6 +193,173 @@ public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: A
   )
 }
 
+// MARK: - Asynchronous functions
+
+/**
+ Asynchronous function without arguments.
+ */
+public func asyncFunction<R>(
+  _ name: String,
+  _ closure: @escaping () throws -> R
+) -> AnyFunction {
+  return AsyncFunction(
+    name,
+    argTypes: [],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with one argument.
+ */
+public func asyncFunction<R, A0: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0) throws -> R
+) -> AnyFunction {
+  return AsyncFunction(
+    name,
+    argTypes: [ArgumentType(A0.self)],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with two arguments.
+ */
+public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1) throws -> R
+) -> AnyFunction {
+  return AsyncFunction(
+    name,
+    argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with three arguments.
+ */
+public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2) throws -> R
+) -> AnyFunction {
+  return AsyncFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with four arguments.
+ */
+public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3) throws -> R
+) -> AnyFunction {
+  return AsyncFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with five arguments.
+ */
+public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3, A4) throws -> R
+) -> AnyFunction {
+  return AsyncFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with six arguments.
+ */
+public func asyncFunction<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 AsyncFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with seven arguments.
+ */
+public func asyncFunction<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 AsyncFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self),
+      ArgumentType(A6.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with eight arguments.
+ */
+public func asyncFunction<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 AsyncFunction(
+    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)
+    ],
+    closure
+  )
+}
+
 // MARK: - Events
 
 /**

package/ios/Swift/SwiftInteropBridge.swift

@@ -11,9 +11,14 @@ public final class SwiftInteropBridge: NSObject {
     appContext.moduleRegistry
   }
 
+  internal init(appContext: AppContext) {
+    self.appContext = appContext
+    super.init()
+  }
+
   @objc
-  public init(modulesProvider: ModulesProviderObjCProtocol, legacyModuleRegistry: EXModuleRegistry) {
-    self.appContext = AppContext(withModulesProvider: modulesProvider as! ModulesProviderProtocol, legacyModuleRegistry: legacyModuleRegistry)
+  public init(modulesProvider: ModulesProvider, legacyModuleRegistry: EXModuleRegistry) {
+    self.appContext = AppContext(withModulesProvider: modulesProvider, legacyModuleRegistry: legacyModuleRegistry)
     super.init()
   }
 
@@ -83,9 +88,13 @@ public final class SwiftInteropBridge: NSObject {
   }
 
   @objc
-  public func exportedViewManagersNames() -> [String] {
-    return registry.compactMap { holder in
-      return holder.definition.viewManager != nil ? holder.name : nil
+  public func viewManagersMetadata() -> [String: Any] {
+    return registry.reduce(into: [String: Any]()) { acc, holder in
+      if let viewManager = holder.definition.viewManager {
+        acc[holder.name] = [
+          "propsNames": viewManager.props.map { $0.name }
+        ]
+      }
     }
   }
 

package/ios/Swift/Views/ComponentData.swift

@@ -1,12 +1,13 @@
 // Copyright 2021-present 650 Industries. All rights reserved.
 
+import React
 
 /**
  Custom component data extending `RCTComponentData`. Its main purpose is to handle event-based props (callbacks),
  but it also simplifies capturing the view config so we can omit some reflections that React Native executes.
  */
 @objc(EXComponentData)
-public final class ComponentData: EXComponentDataCompatibleWrapper {
+public final class ComponentData: RCTComponentData {
   /**
    Weak pointer to the holder of a module that the component data was created for.
    */

package/ios/Swift/Views/ExpoView.swift

@@ -0,0 +1,8 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import React
+
+/**
+ The view that just extends `RCTView`. In the future we may add more features here.
+ */
+open class ExpoView: RCTView {}

package/ios/Swift.h

@@ -1,5 +1,10 @@
 // Copyright 2018-present 650 Industries. All rights reserved.
 
+// The generated swift header may depend on some Objective-C declarations,
+// adding dependency imports here to prevent declarations not found errors.
+#import <ExpoModulesCore/EXDefines.h>
+#import <ExpoModulesCore/RCTComponentData+Privates.h>
+
 // When `use_frameworks!` is used, the generated Swift header is inside ExpoModulesCore module.
 // Otherwise, it's available only locally with double-quoted imports.
 #if __has_include(<ExpoModulesCore/ExpoModulesCore-Swift.h>)

package/ios/Tests/ArgumentTypeSpec.swift

@@ -1,11 +1,10 @@
 // Copyright 2021-present 650 Industries. All rights reserved.
 
-import Quick
-import Nimble
+import ExpoModulesTestCore
 
 @testable import ExpoModulesCore
 
-class ArgumentTypeSpec: QuickSpec {
+class ArgumentTypeSpec: ExpoSpec {
   override func spec() {
     it("casts primitives") {
       let type = ArgumentType(Int.self)

package/ios/Tests/ConstantsSpec.swift

@@ -1,9 +1,8 @@
-import Quick
-import Nimble
+import ExpoModulesTestCore
 
 @testable import ExpoModulesCore
 
-class ConstantsSpec: QuickSpec {
+class ConstantsSpec: ExpoSpec {
   override func spec() {
     let appContext = AppContext()
 

package/ios/Tests/ConvertiblesSpec.swift

@@ -1,12 +1,11 @@
 // Copyright 2018-present 650 Industries. All rights reserved.
 
 import CoreGraphics
-import Quick
-import Nimble
+import ExpoModulesTestCore
 
 @testable import ExpoModulesCore
 
-class ConvertiblesSpec: QuickSpec {
+class ConvertiblesSpec: ExpoSpec {
   override func spec() {
     describe("URL") {
       it("converts from remote url") {

package/ios/Tests/ExceptionsSpec.swift

@@ -1,11 +1,10 @@
 // Copyright 2021-present 650 Industries. All rights reserved.
 
-import Quick
-import Nimble
+import ExpoModulesTestCore
 
 @testable import ExpoModulesCore
 
-final class ExceptionsSpec: QuickSpec {
+final class ExceptionsSpec: ExpoSpec {
   override func spec() {
     it("has name") {
       let error = TestException()

package/ios/Tests/ExpoModulesSpec.swift

@@ -0,0 +1,76 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+class ExpoModulesSpec: ExpoSpec {
+  override func spec() {
+    let appContext = AppContext.create()
+    let interopBridge = SwiftInteropBridge(appContext: appContext)
+    let runtime = appContext.runtime
+    let testModuleName = "TestModule"
+    let testFunctionName = "testFunction"
+    let constantsDict: [String: Any] = [
+      "expo": "is cool",
+      "sdk": 45,
+    ]
+
+    beforeSuite {
+      try! appContext.installExpoModulesHostObject(interopBridge)
+
+      appContext.moduleRegistry.register(holder: mockModuleHolder(appContext) {
+        $0.name(testModuleName)
+
+        constants(constantsDict)
+
+        function(testFunctionName) { Double.pi }
+          .runSynchronously()
+      })
+    }
+
+    describe("host object") {
+      it("is defined") {
+        expect(try! runtime?.eval("'ExpoModules' in this").asBool()) === true
+      }
+
+      it("has native module defined") {
+        expect(try! runtime?.eval("'\(testModuleName)' in ExpoModules").asBool()) === true
+      }
+
+      it("can access native module") {
+        let nativeModule = try! runtime?.eval("ExpoModules.\(testModuleName)")
+        expect(nativeModule?.isUndefined()) == false
+        expect(nativeModule?.isObject()) == true
+        expect(nativeModule?.getRaw()).notTo(beNil())
+      }
+
+      it("has keys for registered modules") {
+        let registeredModuleNames = appContext.moduleRegistry.getModuleNames()
+        let keys = try! runtime?.eval("Object.keys(ExpoModules)").asArray().compactMap {
+          return try! $0?.asString()
+        }
+        expect(keys).to(contain(registeredModuleNames))
+      }
+    }
+
+    describe("module") {
+      it("exposes constants") {
+        let dict = try! runtime!.eval("ExpoModules.TestModule").asDict()
+
+        dict.forEach { (key: String, value: Any) in
+          expect(value) === dict[key]!
+        }
+      }
+
+      it("has function") {
+        expect(try! runtime?.eval("typeof ExpoModules.TestModule.\(testFunctionName)").asString()) == "function"
+        expect(try! runtime?.eval("ExpoModules.TestModule.\(testFunctionName)").isFunction()) == true
+      }
+
+      it("calls function") {
+        expect(try! runtime?.eval("ExpoModules.TestModule.\(testFunctionName)()").asDouble()) == Double.pi
+      }
+    }
+  }
+}

package/ios/Tests/FunctionSpec.swift

@@ -1,9 +1,8 @@
-import Quick
-import Nimble
+import ExpoModulesTestCore
 
 @testable import ExpoModulesCore
 
-class FunctionSpec: QuickSpec {
+class FunctionSpec: ExpoSpec {
   override func spec() {
     let appContext = AppContext()
     let functionName = "test function name"

package/ios/Tests/FunctionWithConvertiblesSpec.swift

@@ -1,12 +1,11 @@
 // Copyright 2018-present 650 Industries. All rights reserved.
 
 import CoreGraphics
-import Quick
-import Nimble
+import ExpoModulesTestCore
 
 @testable import ExpoModulesCore
 
-class FunctionWithConvertiblesSpec: QuickSpec {
+class FunctionWithConvertiblesSpec: ExpoSpec {
   override func spec() {
     let appContext = AppContext()
     let functionName = "function"

package/ios/Tests/JavaScriptObjectSpec.swift

@@ -0,0 +1,97 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+final class JavaScriptObjectSpec: ExpoSpec {
+  override func spec() {
+    let runtime = JavaScriptRuntime()
+    var object: JavaScriptObject?
+
+    let key = "expo"
+    let value1 = "💙"
+    let value2 = "💛"
+
+    beforeEach {
+      object = runtime.createObject()
+    }
+
+    describe("hasProperty") {
+      it("returns false when the property is missing") {
+        expect(object?.hasProperty(key)) == false
+      }
+
+      it("returns true when the property exists") {
+        object?.setProperty(key, value: value1)
+        expect(object?.hasProperty(key)) == true
+      }
+
+      it("returns true when the property is explicitly set to undefined") {
+        object?.setProperty(key, value: nil)
+        expect(object?.hasProperty(key)) == true
+        expect(object?.getProperty(key).isUndefined()) == true
+      }
+    }
+
+    describe("getProperty") {
+      it("returns correct value") {
+        object?.setProperty(key, value: value1)
+        expect(try! object?.getProperty(key).asString()) == value1
+      }
+
+      it("returns undefined") {
+        expect(object?.getProperty("bar").isUndefined()) == true
+      }
+    }
+
+    describe("setProperty") {
+      it("sets") {
+        object?.setProperty(key, value: value1)
+        expect(try! object?.getProperty(key).asString()) == value1
+      }
+
+      it("overrides") {
+        object?.setProperty(key, value: value1)
+        object?.setProperty(key, value: value2)
+        expect(try! object?.getProperty(key).asString()) == value2
+      }
+
+      it("unsets") {
+        object?.setProperty(key, value: nil)
+        expect(object?.getProperty(key).isUndefined()) == true
+      }
+    }
+
+    describe("defineProperty") {
+      it("defines non-enumerable property") {
+        object?.defineProperty(key, value: value1, options: [])
+        expect(try! object?.getProperty(key).asString()) == value1
+        expect(object?.getPropertyNames()).notTo(contain(key))
+      }
+
+      it("defines enumerable property") {
+        // When the property is enumerable, it is listed in the property names
+        object?.defineProperty(key, value: value1, options: .enumerable)
+        expect(try! object?.getProperty(key).asString()) == value1
+        expect(object?.getPropertyNames()).to(contain(key))
+      }
+
+      it("defines configurable property") {
+        // Configurable allows to redefine the property
+        object?.defineProperty(key, value: value1, options: .configurable)
+        expect(try! object?.getProperty(key).asString()) == value1
+        object?.defineProperty(key, value: value2, options: [])
+        expect(try! object?.getProperty(key).asString()) == value2
+      }
+
+      it("defines writable property") {
+        // Writable allows changing the property
+        object?.defineProperty(key, value: value1, options: .writable)
+        expect(try! object?.getProperty(key).asString()) == value1
+        object?.setProperty(key, value: value2)
+        expect(try! object?.getProperty(key).asString()) == value2
+      }
+    }
+  }
+}

package/ios/Tests/JavaScriptRuntimeSpec.swift

@@ -0,0 +1,94 @@
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+class JavaScriptRuntimeSpec: ExpoSpec {
+  override func spec() {
+    let runtime = JavaScriptRuntime()
+
+    it("has global object accessible") {
+      expect(runtime.global) !== nil
+    }
+
+    describe("eval") {
+      it("returns undefined") {
+        let undefined = try! runtime.eval("undefined")
+        expect(undefined.isUndefined()) == true
+        expect(undefined.kind) == .undefined
+        expect(undefined.isNull()) == false
+        expect(undefined.getRaw()).to(beNil())
+      }
+
+      it("returns null") {
+        let null = try! runtime.eval("null")
+        expect(null.isNull()) == true
+        expect(null.kind) == .null
+        expect(null.getRaw()).to(beNil())
+      }
+
+      it("returns bool") {
+        let boolTrue = try! runtime.eval("true")
+        let boolFalse = try! runtime.eval("false")
+        expect(boolTrue.isBool()) == true
+        expect(boolFalse.isBool()) == true
+        expect(boolTrue.kind) == .bool
+        expect(boolFalse.kind) == .bool
+        expect(try! boolTrue.asBool()) == true
+        expect(try! boolFalse.asBool()) == false
+      }
+
+      it("returns number") {
+        let number = try! runtime.eval("1.23")
+        expect(number.isNumber()) == true
+        expect(number.kind) == .number
+        expect(try! number.asInt()) == 1
+        expect(try! number.asDouble()) == 1.23
+      }
+
+      it("returns string") {
+        let string = try! runtime.eval("'foobar'")
+        expect(string.isString()) == true
+        expect(string.kind) == .string
+        expect(try! string.asString()) == "foobar"
+      }
+
+      it("returns array") {
+        let array = try! runtime.eval("(['foo', 'bar'])")
+        expect(array.isObject()) == true
+        expect(array.kind) == .object
+        expect(try! array.asArray().map { try $0?.asString() }) == ["foo", "bar"]
+      }
+
+      it("returns dict") {
+        let dict1 = try! runtime.eval("({ 'foo': 123 })")
+        let dict2 = try! runtime.eval("({ 'foo': 'bar' })")
+        expect(dict1.isObject()) == true
+        expect(dict2.isObject()) == true
+        expect(dict1.kind) == .object
+        expect(dict2.kind) == .object
+        expect(try! dict1.asDict() as? [String: Int]) == ["foo": 123]
+        expect(try! dict2.asDict() as? [String: String]) == ["foo": "bar"]
+      }
+
+      it("returns function") {
+        let function = try! runtime.eval("(function() {})")
+        expect(function.isObject()) == true
+        expect(function.isFunction()) == true
+        expect(function.kind) == .function
+      }
+
+      it("returns symbol") {
+        let symbol = try! runtime.eval("Symbol('foo')")
+        expect(symbol.isSymbol()) == true
+        expect(symbol.kind) == .symbol
+      }
+
+      it("throws evaluation exception") {
+        expect({ try runtime.eval("foo") }).to(throwError { error in
+          expect(error).to(beAKindOf(JavaScriptEvalException.self))
+          expect((error as! JavaScriptEvalException).reason).to(contain("Can't find variable: foo"))
+        })
+      }
+    }
+  }
+}

package/ios/Tests/ModuleEventListenersSpec.swift

@@ -1,5 +1,4 @@
-import Quick
-import Nimble
+import ExpoModulesTestCore
 
 @testable import ExpoModulesCore
 
@@ -11,7 +10,7 @@ import Nimble
 
  NOTE: Each test registers the module because only registered modules can capture events.
  */
-class ModuleEventListenersSpec: QuickSpec {
+class ModuleEventListenersSpec: ExpoSpec {
   override func spec() {
     var appContext: AppContext!