expo-modules-core 0.4.8 → 0.5.0

package/ios/Tests/{MethodSpec.swift → FunctionSpec.swift}

@@ -3,20 +3,19 @@ import Nimble
 
 @testable import ExpoModulesCore
 
-class MethodSpec: QuickSpec {
+class FunctionSpec: QuickSpec {
   override func spec() {
     let appContext = AppContext()
-    let methodName = "test method name"
+    let functionName = "test function name"
 
-    func testMethodReturning<T: Equatable>(value returnValue: T) {
+    func testFunctionReturning<T: Equatable>(value returnValue: T) {
       waitUntil { done in
-        let module = CustomModule(appContext: appContext) {
-          $0.method(methodName) {
+        mockModuleHolder(appContext) {
+          $0.function(functionName) {
             return returnValue
           }
         }
-
-        ModuleHolder(module: module).call(method: methodName, args: []) { value, error in
+        .call(function: functionName, args: []) { value, error in
           expect(value).notTo(beNil())
           expect(value).to(beAKindOf(T.self))
           expect(value as? T).to(equal(returnValue))
@@ -27,34 +26,56 @@ class MethodSpec: QuickSpec {
 
     it("is called") {
       waitUntil { done in
-        let module = CustomModule(appContext: appContext) {
-          $0.method(methodName) {
+        mockModuleHolder(appContext) {
+          $0.function(functionName) {
             done()
           }
         }
-        ModuleHolder(module: module).call(method: methodName, args: [])
+        .call(function: functionName, args: [])
       }
     }
 
     it("returns bool values") {
-      testMethodReturning(value: true)
-      testMethodReturning(value: false)
-      testMethodReturning(value: [true, false])
+      testFunctionReturning(value: true)
+      testFunctionReturning(value: false)
+      testFunctionReturning(value: [true, false])
     }
 
     it("returns int values") {
-      testMethodReturning(value: 1234)
-      testMethodReturning(value: [2, 1, 3, 7])
+      testFunctionReturning(value: 1234)
+      testFunctionReturning(value: [2, 1, 3, 7])
     }
 
     it("returns double values") {
-      testMethodReturning(value: 3.14)
-      testMethodReturning(value: [0, 1.1, 2.2])
+      testFunctionReturning(value: 3.14)
+      testFunctionReturning(value: [0, 1.1, 2.2])
     }
 
     it("returns string values") {
-      testMethodReturning(value: "a string")
-      testMethodReturning(value: ["expo", "modules", "core"])
+      testFunctionReturning(value: "a string")
+      testFunctionReturning(value: ["expo", "modules", "core"])
+    }
+
+    it("is called with nil value") {
+      let str: String? = nil
+
+      mockModuleHolder(appContext) {
+        $0.function(functionName) { (a: String?) in
+          expect(a == nil) == true
+        }
+      }
+      .callSync(function: functionName, args: [str as Any])
+    }
+
+    it("is called with an array of arrays") {
+      let array: [[String]] = [["expo"]]
+
+      mockModuleHolder(appContext) {
+        $0.function(functionName) { (a: [[String]]) in
+          expect(a.first!.first) == array.first!.first
+        }
+      }
+      .callSync(function: functionName, args: [array])
     }
 
     describe("converting dicts to records") {
@@ -69,14 +90,13 @@ class MethodSpec: QuickSpec {
       ]
 
       it("converts to simple record when passed as an argument") {
-        let module = CustomModule(appContext: appContext) {
-          $0.method(methodName) { (a: TestRecord) in
-            return a.property
-          }
-        }
-
         waitUntil { done in
-          ModuleHolder(module: module).call(method: methodName, args: [dict]) { value, error in
+          mockModuleHolder(appContext) {
+            $0.function(functionName) { (a: TestRecord) in
+              return a.property
+            }
+          }
+          .call(function: functionName, args: [dict]) { value, error in
             expect(value).notTo(beNil())
             expect(value).to(beAKindOf(String.self))
             expect(value).to(be(dict["property"]))
@@ -86,14 +106,13 @@ class MethodSpec: QuickSpec {
       }
 
       it("converts to record with custom key") {
-        let module = CustomModule(appContext: appContext) {
-          $0.method(methodName) { (a: TestRecord) in
-            return a.customKeyProperty
-          }
-        }
-
         waitUntil { done in
-          ModuleHolder(module: module).call(method: methodName, args: [dict]) { value, error in
+          mockModuleHolder(appContext) {
+            $0.function(functionName) { (a: TestRecord) in
+              return a.customKeyProperty
+            }
+          }
+          .call(function: functionName, args: [dict]) { value, error in
             expect(value).notTo(beNil())
             expect(value).to(beAKindOf(String.self))
             expect(value).to(be(dict["propertyWithCustomKey"]))
@@ -103,14 +122,13 @@ class MethodSpec: QuickSpec {
       }
 
       it("returns the record back") {
-        let module = CustomModule(appContext: appContext) {
-          $0.method(methodName) { (a: TestRecord) in
-            return a.toDictionary()
-          }
-        }
-
         waitUntil { done in
-          ModuleHolder(module: module).call(method: methodName, args: [dict]) { value, error in
+          mockModuleHolder(appContext) {
+            $0.function(functionName) { (a: TestRecord) in
+              return a.toDictionary()
+            }
+          }
+          .call(function: functionName, args: [dict]) { value, error in
             expect(value).notTo(beNil())
             expect(value).to(beAKindOf(Record.Dict.self))
 
@@ -126,14 +144,13 @@ class MethodSpec: QuickSpec {
 
     it("throws when called with more arguments than expected") {
       waitUntil { done in
-        let module = CustomModule(appContext: appContext) {
-          $0.method(methodName) { (a: Int) in
+        mockModuleHolder(appContext) {
+          $0.function(functionName) { (a: Int) in
             return "something"
           }
         }
-
-        // Method expects one argument, let's give it more.
-        ModuleHolder(module: module).call(method: methodName, args: [1, 2]) { value, error in
+        // Function expects one argument, let's give it more.
+        .call(function: functionName, args: [1, 2]) { value, error in
           expect(error).notTo(beNil())
           expect(error).to(beAKindOf(InvalidArgsNumberError.self))
           expect(error?.code).to(equal("ERR_INVALID_ARGS_NUMBER"))
@@ -145,19 +162,17 @@ class MethodSpec: QuickSpec {
 
     it("throws when called with arguments of incompatible types") {
       waitUntil { done in
-        let module = CustomModule(appContext: appContext) {
-          $0.method(methodName) { (a: String) in
+        mockModuleHolder(appContext) {
+          $0.function(functionName) { (a: String) in
             return "something"
           }
         }
-
-        // Method expects a string, let's give it a number.
-        ModuleHolder(module: module).call(method: methodName, args: [1]) { value, error in
+        // Function expects a string, let's give it a number.
+        .call(function: functionName, args: [1]) { value, error in
           expect(error).notTo(beNil())
-          expect(error).to(beAKindOf(IncompatibleArgTypeError<Any?>.self))
-          expect(error?.code).to(equal("ERR_INCOMPATIBLE_ARG_TYPE"))
-          // TODO: (@tsapeta) The descriptions may not equal yet, due to internal type-erasing. Fix it and uncomment this test.
-          // expect(error?.description).to(equal(IncompatibleArgTypeError(argument: 1, atIndex: 0, desiredType: String.self).description))
+          expect(error).to(beAKindOf(Conversions.CastingError<String>.self))
+          expect(error?.code).to(equal("ERR_CASTING_FAILED"))
+          expect(error?.description).to(equal(Conversions.CastingError<String>(value: 1).description))
           done()
         }
       }

package/ios/Tests/FunctionWithConvertiblesSpec.swift

@@ -0,0 +1,66 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+import CoreGraphics
+import Quick
+import Nimble
+
+@testable import ExpoModulesCore
+
+class FunctionWithConvertiblesSpec: QuickSpec {
+  override func spec() {
+    let appContext = AppContext()
+    let functionName = "function"
+
+    it("converts arguments to CoreGraphics types") {
+      let x = 18.3
+      let y = -4.1
+      let width = 734.6
+      let height = 592.1
+
+      mockModuleHolder(appContext) {
+        $0.function(functionName) { (point: CGPoint, size: CGSize, vector: CGVector, rect: CGRect) in
+          expect(point.x) == x
+          expect(point.y) == y
+          expect(size.width) == width
+          expect(size.height) == height
+          expect(vector.dx) == x
+          expect(vector.dy) == y
+          expect(rect.origin.x) == x
+          expect(rect.origin.y) == y
+          expect(rect.width) == width
+          expect(rect.height) == height
+        }
+      }
+      .callSync(function: functionName, args: [
+        [x, y], // point
+        ["width": width, "height": height], // size
+        ["dx": x, "dy": y], // vector
+        [x, y, width, height] // rect
+      ])
+    }
+
+    it("converts arguments to CGColor") {
+      func testColorComponents(_ color: CGColor, _ red: CGFloat, _ green: CGFloat, _ blue: CGFloat, _ alpha: CGFloat) {
+        expect(color.components?[0]) == red   / 255.0
+        expect(color.components?[1]) == green / 255.0
+        expect(color.components?[2]) == blue  / 255.0
+        expect(color.components?[3]) == alpha / 255.0
+      }
+
+      mockModuleHolder(appContext) {
+        $0.function(functionName) { (color1: CGColor, color2: CGColor, color3: CGColor, color4: CGColor) in
+          testColorComponents(color1, 0x2A, 0x4B, 0x5D, 0xFF)
+          testColorComponents(color2, 0x11, 0xFF, 0x00, 0xDD)
+          testColorComponents(color3, 0x66, 0x00, 0xCC, 0xAA)
+          testColorComponents(color4, 0x00, 0x00, 0x00, 0x00)
+        }
+      }
+      .callSync(function: functionName, args: [
+        "#2A4B5D",
+        0xDD11FF00,
+        "60CA",
+        0
+      ])
+    }
+  }
+}

package/ios/Tests/Mocks/ModuleMocks.swift

@@ -1,4 +1,4 @@
-import ExpoModulesCore
+@testable import ExpoModulesCore
 
 class UnnamedModule: Module {
   func definition() -> ModuleDefinition {}
@@ -13,14 +13,28 @@ class NamedModule: Module {
 }
 
 class CustomModule: Module {
-  var customDefinition: ((CustomModule) -> ModuleDefinition)!
+  let body: MockedDefinitionFunc
 
-  convenience init(appContext: AppContext, @ModuleDefinitionBuilder _ customDefinition: @escaping (CustomModule) -> ModuleDefinition) {
-    self.init(appContext: appContext)
-    self.customDefinition = customDefinition
+  func definition() -> ModuleDefinition {
+    return body(self)
   }
 
-  func definition() -> ModuleDefinition {
-    return customDefinition(self)
+  init(appContext: AppContext, _ body: @escaping MockedDefinitionFunc) {
+    self.body = body
+    super.init(appContext: appContext)
   }
+
+  required init(appContext: AppContext) {
+    fatalError("`init(appContext:)` is unavailable in mocked module class.")
+  }
+}
+
+typealias MockedDefinitionFunc = (CustomModule) -> ModuleDefinition
+
+func mockModuleHolder(_ appContext: AppContext, @ModuleDefinitionBuilder _ definitionBody: @escaping () -> ModuleDefinition) -> ModuleHolder {
+  return ModuleHolder(appContext: appContext, module: CustomModule(appContext: appContext, { module in definitionBody() }))
+}
+
+func mockModuleHolder(_ appContext: AppContext, @ModuleDefinitionBuilder _ definitionBody: @escaping (CustomModule) -> ModuleDefinition) -> ModuleHolder {
+  return ModuleHolder(appContext: appContext, module: CustomModule(appContext: appContext, { module in definitionBody(module) }))
 }

package/ios/Tests/ModuleEventListenersSpec.swift

@@ -19,39 +19,40 @@ class ModuleEventListenersSpec: QuickSpec {
       appContext = AppContext()
     }
 
-    it("calls onCreate once the module is registered") {
+    it("calls onCreate once the module instance is created") {
       waitUntil { done in
-        let module = CustomModule(appContext: appContext) {
+        let _ = mockModuleHolder(appContext) {
           $0.onCreate {
             done()
           }
         }
-        appContext.moduleRegistry.register(module: module)
       }
     }
 
     it("calls onDestroy once the module is about to be deallocated") {
       waitUntil { done in
-        let module = CustomModule(appContext: appContext) {
+        let moduleName = "mockedModule"
+        let holder = mockModuleHolder(appContext) {
+          $0.name(moduleName)
           $0.onDestroy {
             done()
           }
         }
-        appContext.moduleRegistry.register(module: module)
+        appContext.moduleRegistry.register(holder: holder)
         // Unregister the module to deallocate its holder
-        appContext.moduleRegistry.unregister(module: module)
+        appContext.moduleRegistry.unregister(moduleName: holder.name)
         // The `module` object is actually still alive, but its holder is dead
       }
     }
 
     it("calls onAppContextDestroys once the context destroys") {
       waitUntil { done in
-        let module = CustomModule(appContext: appContext) {
+        let holder = mockModuleHolder(appContext) {
           $0.onAppContextDestroys {
             done()
           }
         }
-        appContext.moduleRegistry.register(module: module)
+        appContext.moduleRegistry.register(holder: holder)
         appContext = nil // This must deallocate the app context
       }
     }
@@ -59,48 +60,48 @@ class ModuleEventListenersSpec: QuickSpec {
     it("calls custom event listener when the event is sent to the registry") {
       waitUntil { done in
         let event = EventName.custom("custom event name")
-        let module = CustomModule(appContext: appContext) { _ in
+        let holder = mockModuleHolder(appContext) {
           EventListener(event) {
             done()
           }
         }
-        appContext.moduleRegistry.register(module: module)
+        appContext.moduleRegistry.register(holder: holder)
         appContext.moduleRegistry.post(event: event)
       }
     }
 
     it("calls onAppEntersForeground when system's willEnterForegroundNotification is sent") {
       waitUntil { done in
-        let module = CustomModule(appContext: appContext) {
+        let holder = mockModuleHolder(appContext) {
           $0.onAppEntersForeground {
             done()
           }
         }
-        appContext.moduleRegistry.register(module: module)
+        appContext.moduleRegistry.register(holder: holder)
         NotificationCenter.default.post(name: UIApplication.willEnterForegroundNotification, object: nil)
       }
     }
 
     it("calls onAppBecomesActive when system's didBecomeActiveNotification is sent") {
       waitUntil { done in
-        let module = CustomModule(appContext: appContext) {
+        let holder = mockModuleHolder(appContext) {
           $0.onAppBecomesActive {
             done()
           }
         }
-        appContext.moduleRegistry.register(module: module)
+        appContext.moduleRegistry.register(holder: holder)
         NotificationCenter.default.post(name: UIApplication.didBecomeActiveNotification, object: nil)
       }
     }
 
     it("calls onAppEntersBackground when system's didEnterBackgroundNotification is sent") {
       waitUntil { done in
-        let module = CustomModule(appContext: appContext) {
+        let holder = mockModuleHolder(appContext) {
           $0.onAppEntersBackground {
             done()
           }
         }
-        appContext.moduleRegistry.register(module: module)
+        appContext.moduleRegistry.register(holder: holder)
         NotificationCenter.default.post(name: UIApplication.didEnterBackgroundNotification, object: nil)
       }
     }

package/ios/Tests/ModuleRegistrySpec.swift

@@ -8,22 +8,19 @@ class ModuleRegistrySpec: QuickSpec {
     let appContext = AppContext()
 
     it("registers unnamed module") {
-      testRegister(module: UnnamedModule(appContext: appContext), name: String(describing: UnnamedModule.self))
+      testRegister(moduleType: UnnamedModule.self, name: String(describing: UnnamedModule.self))
     }
 
     it("registers named module") {
-      testRegister(module: NamedModule(appContext: appContext), name: NamedModule.namedModuleName)
+      testRegister(moduleType: NamedModule.self, name: NamedModule.namedModuleName)
     }
 
-    func testRegister(module: Module, name: String) {
+    func testRegister<ModuleType: AnyModule>(moduleType: ModuleType.Type, name: String) {
       let moduleRegistry = appContext.moduleRegistry
 
-      moduleRegistry.register(module: module)
+      moduleRegistry.register(moduleType: moduleType)
 
       expect(moduleRegistry.has(moduleWithName: name)).to(beTrue())
-      expect(moduleRegistry.get(moduleWithName: name)).to(beIdenticalTo(module))
-      expect(moduleRegistry.contains { $0.module === module }).to(beTrue())
-      expect(moduleRegistry.get(moduleHolderForName: name)?.module).to(beIdenticalTo(module))
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "0.4.8",
+  "version": "0.5.0",
   "description": "The core of Expo Modules architecture",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -32,7 +32,7 @@
   "license": "MIT",
   "homepage": "https://github.com/expo/expo/tree/master/packages/expo-modules-core",
   "jest": {
-    "preset": "expo-module-scripts/ios"
+    "preset": "expo-module-scripts"
   },
   "dependencies": {
     "compare-versions": "^3.4.0",
@@ -42,5 +42,5 @@
     "@testing-library/react-hooks": "^7.0.1",
     "expo-module-scripts": "^2.0.0"
   },
-  "gitHead": "f93456e96091501a9b9f99246846cee29336a964"
+  "gitHead": "9faa58818454ba59dbff95077b9025a1c1cbd9fd"
 }

package/src/NativeModulesProxy.native.ts

@@ -1,6 +1,11 @@
 import { NativeModules } from 'react-native';
 
-import { ProxyNativeModule } from './NativeModulesProxy.types';
+import { ProxyNativeModule, TurboNativeModuleProxy } from './NativeModulesProxy.types';
+
+// `ExpoModulesProxy` is not declared in TypeScript yet. It's installed via JSI.
+declare namespace global {
+  const ExpoModulesProxy: TurboNativeModuleProxy;
+}
 
 const NativeProxy = NativeModules.NativeUnimoduleProxy;
 const modulesConstantsKey = 'modulesConstants';
@@ -8,6 +13,16 @@ const exportedMethodsKey = 'exportedMethods';
 
 const NativeModulesProxy: { [moduleName: string]: ProxyNativeModule } = {};
 
+// Keep it opt-in for now. It's too risky without proper and thorough testing.
+let canUseExpoTurboModules = false;
+
+/**
+ * Sets whether to use a TurboModule version of the proxy.
+ */
+export function useExpoTurboModules(state: boolean = true) {
+  canUseExpoTurboModules = state;
+}
+
 if (NativeProxy) {
   Object.keys(NativeProxy[exportedMethodsKey]).forEach((moduleName) => {
     NativeModulesProxy[moduleName] = NativeProxy[modulesConstantsKey][moduleName] || {};
@@ -23,7 +38,12 @@ if (NativeProxy) {
             )
           );
         }
-        return NativeProxy.callMethod(moduleName, key, args);
+
+        if (canUseExpoTurboModules && global.ExpoModulesProxy) {
+          return global.ExpoModulesProxy.callMethodAsync(moduleName, methodInfo.name, args);
+        } else {
+          return NativeProxy.callMethod(moduleName, key, args);
+        }
       };
     });
 

package/src/NativeModulesProxy.types.ts

@@ -3,3 +3,11 @@ export type ProxyNativeModule = {
   addListener: (eventName: string) => void;
   removeListeners: (count: number) => void;
 };
+
+export type TurboNativeModuleProxy = {
+  callMethodAsync: <ReturnType>(
+    moduleName: string,
+    methodName: string,
+    args: any[]
+  ) => Promise<ReturnType>;
+};

package/ios/EXAppDelegateWrapper.h

@@ -1,13 +0,0 @@
-// Copyright © 2018 650 Industries. All rights reserved.
-
-#import <Foundation/Foundation.h>
-#import <UIKit/UIKit.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-NS_SWIFT_NAME(AppDelegateWrapper)
-@interface EXAppDelegateWrapper : UIResponder <UIApplicationDelegate>
-
-@end
-
-NS_ASSUME_NONNULL_END

package/ios/Swift/Methods/AnyArgumentType.swift

@@ -1,48 +0,0 @@
-
-struct AnyArgumentType: CustomDebugStringConvertible {
-  let baseType: Any.Type
-  let typeName: String
-
-  private let castHelper: (Any) -> AnyMethodArgument?
-  private let canCastHelper: (Any) -> Bool
-
-  init<T: AnyMethodArgument>(_ baseType: T.Type) {
-    self.baseType = baseType
-    self.typeName = String(describing: baseType)
-    self.castHelper = { $0 as? T }
-
-    // handle class metatypes separately in order to allow T.self != base.
-    if baseType is AnyClass {
-      self.canCastHelper = { x in
-        sequence(
-          first: Mirror(reflecting: x), next: { $0.superclassMirror }
-        )
-        .contains { $0.subjectType == baseType }
-      }
-    } else {
-      self.canCastHelper = { $0 is T }
-    }
-  }
-
-  func cast<T>(_ object: T) -> AnyMethodArgument? {
-    return castHelper(object)
-  }
-
-  func canCast<T>(_ object: T) -> Bool {
-    return canCastHelper(object)
-  }
-
-  func canCastToType<T>(_ type: T.Type) -> Bool {
-    return baseType is T.Type
-  }
-
-  func castWrappedType<T>(_ type: T.Type) -> T? {
-    return baseType as? T
-  }
-
-  // MARK: CustomDebugStringConvertible
-
-  var debugDescription: String {
-    return String(describing: baseType)
-  }
-}

package/ios/Swift/Methods/AnyMethod.swift

@@ -1,31 +0,0 @@
-import Dispatch
-
-/**
- A protocol for any type-erased module's method.
- */
-public protocol AnyMethod: AnyDefinition {
-  /**
-   Name of the exported method. JavaScript refers to the method by this name.
-   */
-  var name: String { get }
-
-  /**
-   A number of arguments the method takes. If the last argument is of type `Promise`, it is not counted.
-   */
-  var argumentsCount: Int { get }
-
-  /**
-   Dispatch queue on which each method's call is run.
-   */
-  var queue: DispatchQueue? { get }
-
-  /**
-   Calls the method with given arguments and a promise.
-   */
-  func call(args: [Any?], promise: Promise) -> Void
-
-  /**
-   Specifies on which queue the method should run.
-   */
-  func runOnQueue(_ queue: DispatchQueue?) -> Self
-}

package/ios/Swift/Methods/AnyMethodArgument.swift

@@ -1,13 +0,0 @@
-
-/**
- A protocol for classes/structs accepted as an argument of exported methods.
- */
-public protocol AnyMethodArgument {}
-
-// Extend the primitive types — these may come from React Native bridge.
-extension Bool: AnyMethodArgument {}
-extension Int: AnyMethodArgument {}
-extension Double: AnyMethodArgument {}
-extension String: AnyMethodArgument {}
-extension Array: AnyMethodArgument {}
-extension Dictionary: AnyMethodArgument {}