expo-modules-core 0.6.1 → 0.7.0

package/ios/Tests/FunctionSpec.swift

@@ -11,11 +11,11 @@ class FunctionSpec: QuickSpec {
     func testFunctionReturning<T: Equatable>(value returnValue: T) {
       waitUntil { done in
         mockModuleHolder(appContext) {
-          $0.function(functionName) {
+          function(functionName) {
             return returnValue
           }
         }
-        .call(function: functionName, args: []) { value, error in
+        .call(function: functionName, args: []) { value, _ in
           expect(value).notTo(beNil())
           expect(value).to(beAKindOf(T.self))
           expect(value as? T).to(equal(returnValue))
@@ -27,7 +27,7 @@ class FunctionSpec: QuickSpec {
     it("is called") {
       waitUntil { done in
         mockModuleHolder(appContext) {
-          $0.function(functionName) {
+          function(functionName) {
             done()
           }
         }
@@ -42,7 +42,7 @@ class FunctionSpec: QuickSpec {
     }
 
     it("returns int values") {
-      testFunctionReturning(value: 1234)
+      testFunctionReturning(value: 1_234)
       testFunctionReturning(value: [2, 1, 3, 7])
     }
 
@@ -60,7 +60,7 @@ class FunctionSpec: QuickSpec {
       let str: String? = nil
 
       mockModuleHolder(appContext) {
-        $0.function(functionName) { (a: String?) in
+        function(functionName) { (a: String?) in
           expect(a == nil) == true
         }
       }
@@ -71,7 +71,7 @@ class FunctionSpec: QuickSpec {
       let array: [[String]] = [["expo"]]
 
       mockModuleHolder(appContext) {
-        $0.function(functionName) { (a: [[String]]) in
+        function(functionName) { (a: [[String]]) in
           expect(a.first!.first) == array.first!.first
         }
       }
@@ -81,7 +81,7 @@ class FunctionSpec: QuickSpec {
     describe("converting dicts to records") {
       struct TestRecord: Record {
         @Field var property: String = "expo"
-        @Field var optionalProperty: Int? = nil
+        @Field var optionalProperty: Int?
         @Field("propertyWithCustomKey") var customKeyProperty: String = "expo"
       }
       let dict = [
@@ -92,11 +92,11 @@ class FunctionSpec: QuickSpec {
       it("converts to simple record when passed as an argument") {
         waitUntil { done in
           mockModuleHolder(appContext) {
-            $0.function(functionName) { (a: TestRecord) in
+            function(functionName) { (a: TestRecord) in
               return a.property
             }
           }
-          .call(function: functionName, args: [dict]) { value, error in
+          .call(function: functionName, args: [dict]) { value, _ in
             expect(value).notTo(beNil())
             expect(value).to(beAKindOf(String.self))
             expect(value).to(be(dict["property"]))
@@ -108,11 +108,11 @@ class FunctionSpec: QuickSpec {
       it("converts to record with custom key") {
         waitUntil { done in
           mockModuleHolder(appContext) {
-            $0.function(functionName) { (a: TestRecord) in
+            function(functionName) { (a: TestRecord) in
               return a.customKeyProperty
             }
           }
-          .call(function: functionName, args: [dict]) { value, error in
+          .call(function: functionName, args: [dict]) { value, _ in
             expect(value).notTo(beNil())
             expect(value).to(beAKindOf(String.self))
             expect(value).to(be(dict["propertyWithCustomKey"]))
@@ -124,11 +124,11 @@ class FunctionSpec: QuickSpec {
       it("returns the record back") {
         waitUntil { done in
           mockModuleHolder(appContext) {
-            $0.function(functionName) { (a: TestRecord) in
+            function(functionName) { (a: TestRecord) in
               return a.toDictionary()
             }
           }
-          .call(function: functionName, args: [dict]) { value, error in
+          .call(function: functionName, args: [dict]) { value, _ in
             expect(value).notTo(beNil())
             expect(value).to(beAKindOf(Record.Dict.self))
 
@@ -145,16 +145,15 @@ class FunctionSpec: QuickSpec {
     it("throws when called with more arguments than expected") {
       waitUntil { done in
         mockModuleHolder(appContext) {
-          $0.function(functionName) { (a: Int) in
+          function(functionName) { (_: Int) in
             return "something"
           }
         }
         // Function expects one argument, let's give it more.
-        .call(function: functionName, args: [1, 2]) { value, error in
+        .call(function: functionName, args: [1, 2]) { _, error in
           expect(error).notTo(beNil())
-          expect(error).to(beAKindOf(InvalidArgsNumberError.self))
-          expect(error?.code).to(equal("ERR_INVALID_ARGS_NUMBER"))
-          expect(error?.description).to(equal(InvalidArgsNumberError(received: 2, expected: 1).description))
+          expect(error).to(beAKindOf(FunctionCallException.self))
+          expect((error as! Exception).isCausedBy(InvalidArgsNumberException.self)) == true
           done()
         }
       }
@@ -163,16 +162,15 @@ class FunctionSpec: QuickSpec {
     it("throws when called with arguments of incompatible types") {
       waitUntil { done in
         mockModuleHolder(appContext) {
-          $0.function(functionName) { (a: String) in
+          function(functionName) { (_: String) in
             return "something"
           }
         }
         // 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(Conversions.CastingError<String>.self))
-          expect(error?.code).to(equal("ERR_CASTING_FAILED"))
-          expect(error?.description).to(equal(Conversions.CastingError<String>(value: 1).description))
+          expect(error).to(beAKindOf(FunctionCallException.self))
+          expect((error as! Exception).isCausedBy(Conversions.CastingException<String>.self)) == true
           done()
         }
       }

package/ios/Tests/FunctionWithConvertiblesSpec.swift

@@ -18,7 +18,7 @@ class FunctionWithConvertiblesSpec: QuickSpec {
       let height = 592.1
 
       mockModuleHolder(appContext) {
-        $0.function(functionName) { (point: CGPoint, size: CGSize, vector: CGVector, rect: CGRect) in
+        function(functionName) { (point: CGPoint, size: CGSize, vector: CGVector, rect: CGRect) in
           expect(point.x) == x
           expect(point.y) == y
           expect(size.width) == width
@@ -48,7 +48,7 @@ class FunctionWithConvertiblesSpec: QuickSpec {
       }
 
       mockModuleHolder(appContext) {
-        $0.function(functionName) { (color1: CGColor, color2: CGColor, color3: CGColor, color4: CGColor) in
+        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)

package/ios/Tests/Mocks/ModuleMocks.swift

@@ -32,7 +32,7 @@ class CustomModule: Module {
 typealias MockedDefinitionFunc = (CustomModule) -> ModuleDefinition
 
 func mockModuleHolder(_ appContext: AppContext, @ModuleDefinitionBuilder _ definitionBody: @escaping () -> ModuleDefinition) -> ModuleHolder {
-  return ModuleHolder(appContext: appContext, module: CustomModule(appContext: appContext, { module in definitionBody() }))
+  return ModuleHolder(appContext: appContext, module: CustomModule(appContext: appContext, { _ in definitionBody() }))
 }
 
 func mockModuleHolder(_ appContext: AppContext, @ModuleDefinitionBuilder _ definitionBody: @escaping (CustomModule) -> ModuleDefinition) -> ModuleHolder {

package/ios/Tests/Mocks/ModulesProviderMock.swift

@@ -3,7 +3,6 @@ import ExpoModulesCore
 public class ModulesProviderMock: ModulesProvider {
   public override func getModuleClasses() -> [AnyModule.Type] {
     return [
-
     ]
   }
 }

package/ios/Tests/ModuleEventListenersSpec.swift

@@ -21,7 +21,7 @@ class ModuleEventListenersSpec: QuickSpec {
 
     it("calls onCreate once the module instance is created") {
       waitUntil { done in
-        let _ = mockModuleHolder(appContext) {
+        _ = mockModuleHolder(appContext) {
           $0.onCreate {
             done()
           }

package/ios/Tests/RecordSpec.swift

@@ -7,7 +7,7 @@ class RecordSpec: QuickSpec {
   override func spec() {
     it("initializes with empty dictionary") {
       struct TestRecord: Record { }
-      let _ = try TestRecord(from: [:])
+      _ = try TestRecord(from: [:])
     }
 
     it("works back and forth with a field") {
@@ -37,14 +37,9 @@ class RecordSpec: QuickSpec {
         @Field(.required) var a: Int
       }
 
-      do {
-        let _ = try TestRecord(from: [:])
-        fail()
-      } catch let error as CodedError {
-        expect(error).to(beAKindOf(FieldRequiredError.self))
-        expect(error.code).to(equal("ERR_FIELD_REQUIRED"))
-        expect(error.description).to(equal(FieldRequiredError(fieldKey: "a").description))
-      }
+      expect { try TestRecord(from: [:]) }.to(throwError { error in
+        expect(error).to(beAKindOf(FieldRequiredException.self))
+      })
     }
 
     it("throws when casting is not possible") {
@@ -53,14 +48,9 @@ class RecordSpec: QuickSpec {
       }
       let dict = ["a": "try with String instead of Int"]
 
-      do {
-        let _ = try TestRecord(from: dict)
-        fail()
-      } catch let error as CodedError {
-        expect(error).to(beAKindOf(FieldInvalidTypeError.self))
-        expect(error.code).to(equal("ERR_FIELD_INVALID_TYPE"))
-        expect(error.description).to(equal(FieldInvalidTypeError(fieldKey: "a", value: dict["a"], desiredType: Int.self).description))
-      }
+      expect { try TestRecord(from: dict) }.to(throwError { error in
+        expect(error).to(beAKindOf(FieldInvalidTypeException.self))
+      })
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "The core of Expo Modules architecture",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -30,7 +30,7 @@
   },
   "author": "650 Industries, Inc.",
   "license": "MIT",
-  "homepage": "https://github.com/expo/expo/tree/master/packages/expo-modules-core",
+  "homepage": "https://github.com/expo/expo/tree/main/packages/expo-modules-core",
   "jest": {
     "preset": "expo-module-scripts"
   },
@@ -42,5 +42,5 @@
     "@testing-library/react-hooks": "^7.0.1",
     "expo-module-scripts": "^2.0.0"
   },
-  "gitHead": "cf8e7fde1b19e10dd9b74a8af0e9362ae8e14001"
+  "gitHead": "e1ff1a3d6bc62f374e6947a5e81428a1bb7cfa34"
 }

package/src/index.ts

@@ -9,6 +9,8 @@ import SyntheticPlatformEmitter from './SyntheticPlatformEmitter';
 import { CodedError } from './errors/CodedError';
 import { UnavailabilityError } from './errors/UnavailabilityError';
 
+import './sweet/setUpErrorManager.fx';
+
 export { default as deprecate } from './deprecate';
 
 export {
@@ -25,6 +27,8 @@ export {
   UnavailabilityError,
 };
 
+export * from './requireNativeModule';
+
 /**
  * @deprecated renamed to `DeviceEventEmitter`
  */

package/src/requireNativeModule.ts

@@ -0,0 +1,29 @@
+import NativeModulesProxy from './NativeModulesProxy';
+
+declare global {
+  // eslint-disable-next-line no-var
+  var ExpoModules:
+    | undefined
+    | {
+        [key: string]: any;
+      };
+}
+
+/**
+ * Imports the native module registered with given name. In the first place it tries to load
+ * the module installed through the JSI host object and then falls back to the bridge proxy module.
+ * Notice that the modules loaded from the proxy may not support some features like synchronous functions.
+ *
+ * @param moduleName Name of the requested native module.
+ * @returns Object representing the native module.
+ * @throws Error when there is no native module with given name.
+ */
+export function requireNativeModule<ModuleType = any>(moduleName: string): ModuleType {
+  const nativeModule: ModuleType =
+    global.ExpoModules?.[moduleName] ?? NativeModulesProxy[moduleName];
+
+  if (!nativeModule) {
+    throw new Error(`Cannot find native module '${moduleName}'`);
+  }
+  return nativeModule;
+}

package/src/sweet/NativeErrorManager.ts

@@ -0,0 +1,2 @@
+import { NativeModulesProxy } from '..';
+export default NativeModulesProxy.ExpoModulesCoreErrorManager;

package/src/sweet/setUpErrorManager.fx.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from '../EventEmitter';
+import Platform from '../Platform';
+import NativeErrorManager from './NativeErrorManager';
+
+if (__DEV__ && Platform.OS === 'android' && NativeErrorManager) {
+  const onNewException = 'ExpoModulesCoreErrorManager.onNewException';
+  const eventEmitter = new EventEmitter(NativeErrorManager);
+
+  eventEmitter.addListener(onNewException, ({ message }: { message: string }) => {
+    console.error(message);
+  });
+}