expo-modules-core 0.6.4 → 0.7.0

package/ios/Swift/Views/ViewManagerDefinitionComponents.swift

@@ -0,0 +1,26 @@
+/// Here we implement the components exclusive for view managers.
+
+// MARK: View factory
+
+/**
+ Defines the factory creating a native view when the module is used as a view.
+ */
+public func view(_ closure: @escaping () -> UIView) -> ViewManagerDefinitionComponent {
+  return ViewFactory(closure)
+}
+
+// MARK: Props
+
+/**
+ Creates a view prop that defines its name and setter.
+ */
+public func prop<ViewType: UIView, PropType: AnyArgument>(
+  _ name: String,
+  _ setter: @escaping (ViewType, PropType) -> Void
+) -> ViewManagerDefinitionComponent {
+  return ConcreteViewProp(
+    name: name,
+    propType: ArgumentType(PropType.self),
+    setter: setter
+  )
+}

package/ios/Swift/Views/ViewModuleWrapper.swift

@@ -93,7 +93,7 @@ public final class ViewModuleWrapper: RCTViewManager, DynamicModuleWrapperProtoc
    */
   @objc
   public class func propConfig_proxiedProperties() -> [String] {
-    return ["NSDictionary", "__custom__"];
+    return ["NSDictionary", "__custom__"]
   }
 
   /**
@@ -126,7 +126,7 @@ public final class ViewModuleWrapper: RCTViewManager, DynamicModuleWrapperProtoc
     let prefixedViewName = "ViewManagerAdapter_\(module.name())"
 
     return prefixedViewName.withCString { viewNamePtr in
-      // Create a new meta class that inherits from `ViewModuleWrapper`. The class name passed here, doesn't work for Swift classes,
+      // Create a new class that inherits from `ViewModuleWrapper`. The class name passed here, doesn't work for Swift classes,
       // so we also have to override `moduleName` class method.
       let wrapperClass: AnyClass? = objc_allocateClassPair(ViewModuleWrapper.self, viewNamePtr, 0)
 
@@ -141,3 +141,6 @@ public final class ViewModuleWrapper: RCTViewManager, DynamicModuleWrapperProtoc
     }
   }
 }
+
+// The direct event implementation can be cached and lazy-loaded (global and static variables are lazy by default in Swift).
+let directEventBlockImplementation = imp_implementationWithBlock({ ["RCTDirectEventBlock"] } as @convention(block) () -> [String])

package/ios/Tests/ArgumentTypeSpec.swift

@@ -7,7 +7,6 @@ import Nimble
 
 class ArgumentTypeSpec: QuickSpec {
   override func spec() {
-
     it("casts primitives") {
       let type = ArgumentType(Int.self)
       let value = 123
@@ -34,7 +33,7 @@ class ArgumentTypeSpec: QuickSpec {
       let value: Double? = nil
       let anyValue = value as Any
 
-      expect { try type.cast(anyValue) }.to(throwError(errorType: Conversions.NullCastError<Double>.self))
+      expect { try type.cast(anyValue) }.to(throwError(errorType: Conversions.NullCastException<Double>.self))
     }
 
     it("casts arrays") {
@@ -104,7 +103,7 @@ class ArgumentTypeSpec: QuickSpec {
 
         // "841" is not a raw value of any `IntTestEnum` case
         expect { try type.cast("string instead of int") }.to(throwError {
-          expect($0).to(beAKindOf(EnumCastingError.self))
+          expect($0).to(beAKindOf(EnumCastingException.self))
         })
       }
 
@@ -113,7 +112,7 @@ class ArgumentTypeSpec: QuickSpec {
 
         // "841" is not a raw value of any `IntTestEnum` case
         expect { try type.cast(841) }.to(throwError {
-          expect($0).to(beAKindOf(EnumNoSuchValueError.self))
+          expect($0).to(beAKindOf(EnumNoSuchValueException.self))
         })
       }
 

package/ios/Tests/ConstantsSpec.swift

@@ -9,7 +9,7 @@ class ConstantsSpec: QuickSpec {
 
     it("takes closure resolving to dictionary") {
       let holder = mockModuleHolder(appContext) {
-        $0.constants {
+        constants {
           return ["test": 123]
         }
       }
@@ -18,15 +18,15 @@ class ConstantsSpec: QuickSpec {
 
     it("takes the dictionary") {
       let holder = mockModuleHolder(appContext) {
-        $0.constants(["test": 123])
+        constants(["test": 123])
       }
       expect(holder.getConstants()["test"] as? Int) == 123
     }
 
     it("merges multiple constants definitions") {
       let holder = mockModuleHolder(appContext) {
-        $0.constants(["test": 456, "test2": 789])
-        $0.constants(["test": 123])
+        constants(["test": 456, "test2": 789])
+        constants(["test": 123])
       }
       let consts = holder.getConstants()
       expect(consts["test"] as? Int) == 123

package/ios/Tests/ConvertiblesSpec.swift

@@ -37,7 +37,7 @@ class ConvertiblesSpec: QuickSpec {
 
       it("throws when no string") {
         expect { try URL.convert(from: 29.5) }.to(
-          throwError(errorType: Conversions.ConvertingError<URL>.self)
+          throwError(errorType: Conversions.ConvertingException<URL>.self)
         )
       }
     }
@@ -61,22 +61,22 @@ class ConvertiblesSpec: QuickSpec {
       }
 
       it("throws when array size is unexpected") { // different than two
-        expect { try CGPoint.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingError<CGPoint>.self))
-        expect { try CGPoint.convert(from: [x]) }.to(throwError(errorType: Conversions.ConvertingError<CGPoint>.self))
-        expect { try CGPoint.convert(from: [x, y, x]) }.to(throwError(errorType: Conversions.ConvertingError<CGPoint>.self))
+        expect { try CGPoint.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingException<CGPoint>.self))
+        expect { try CGPoint.convert(from: [x]) }.to(throwError(errorType: Conversions.ConvertingException<CGPoint>.self))
+        expect { try CGPoint.convert(from: [x, y, x]) }.to(throwError(errorType: Conversions.ConvertingException<CGPoint>.self))
       }
 
       it("throws when dict is missing some keys") {
         expect { try CGPoint.convert(from: ["test": x]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.MissingKeysError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.MissingKeysError<Double>(keys: ["x", "y"]).description
+          expect($0).to(beAKindOf(Conversions.MissingKeysException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.MissingKeysException<Double>(["x", "y"]).description
         })
       }
 
       it("throws when dict has uncastable keys") {
         expect { try CGPoint.convert(from: ["x": x, "y": "string"]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.CastingValuesError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.CastingValuesError<Double>(keys: ["y"]).description
+          expect($0).to(beAKindOf(Conversions.CastingValuesException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.CastingValuesException<Double>(["y"]).description
         })
       }
     }
@@ -100,22 +100,22 @@ class ConvertiblesSpec: QuickSpec {
       }
 
       it("throws when array size is unexpected") { // different than two
-        expect { try CGSize.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingError<CGSize>.self))
-        expect { try CGSize.convert(from: [width]) }.to(throwError(errorType: Conversions.ConvertingError<CGSize>.self))
-        expect { try CGSize.convert(from: [width, height, width]) }.to(throwError(errorType: Conversions.ConvertingError<CGSize>.self))
+        expect { try CGSize.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingException<CGSize>.self))
+        expect { try CGSize.convert(from: [width]) }.to(throwError(errorType: Conversions.ConvertingException<CGSize>.self))
+        expect { try CGSize.convert(from: [width, height, width]) }.to(throwError(errorType: Conversions.ConvertingException<CGSize>.self))
       }
 
       it("throws when dict is missing some keys") {
         expect { try CGSize.convert(from: ["width": width]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.MissingKeysError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.MissingKeysError<Double>(keys: ["height"]).description
+          expect($0).to(beAKindOf(Conversions.MissingKeysException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.MissingKeysException<Double>(["height"]).description
         })
       }
 
       it("throws when dict has uncastable keys") {
         expect { try CGSize.convert(from: ["width": "test", "height": height]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.CastingValuesError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.CastingValuesError<Double>(keys: ["width"]).description
+          expect($0).to(beAKindOf(Conversions.CastingValuesException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.CastingValuesException<Double>(["width"]).description
         })
       }
     }
@@ -139,22 +139,22 @@ class ConvertiblesSpec: QuickSpec {
       }
 
       it("throws when array size is unexpected") { // different than two
-        expect { try CGVector.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingError<CGVector>.self))
-        expect { try CGVector.convert(from: [dx]) }.to(throwError(errorType: Conversions.ConvertingError<CGVector>.self))
-        expect { try CGVector.convert(from: [dx, dy, dx]) }.to(throwError(errorType: Conversions.ConvertingError<CGVector>.self))
+        expect { try CGVector.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingException<CGVector>.self))
+        expect { try CGVector.convert(from: [dx]) }.to(throwError(errorType: Conversions.ConvertingException<CGVector>.self))
+        expect { try CGVector.convert(from: [dx, dy, dx]) }.to(throwError(errorType: Conversions.ConvertingException<CGVector>.self))
       }
 
       it("throws when dict is missing some keys") {
         expect { try CGVector.convert(from: ["dx": dx]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.MissingKeysError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.MissingKeysError<Double>(keys: ["dy"]).description
+          expect($0).to(beAKindOf(Conversions.MissingKeysException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.MissingKeysException<Double>(["dy"]).description
         })
       }
 
       it("throws when dict has uncastable keys") {
         expect { try CGVector.convert(from: ["dx": "dx", "dy": dy]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.CastingValuesError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.CastingValuesError<Double>(keys: ["dx"]).description
+          expect($0).to(beAKindOf(Conversions.CastingValuesException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.CastingValuesException<Double>(["dx"]).description
         })
       }
     }
@@ -184,22 +184,22 @@ class ConvertiblesSpec: QuickSpec {
       }
 
       it("throws when array size is unexpected") { // different than four
-        expect { try CGRect.convert(from: [x]) }.to(throwError(errorType: Conversions.ConvertingError<CGRect>.self))
-        expect { try CGRect.convert(from: [x, y]) }.to(throwError(errorType: Conversions.ConvertingError<CGRect>.self))
-        expect { try CGRect.convert(from: [x, y, width, height, y]) }.to(throwError(errorType: Conversions.ConvertingError<CGRect>.self))
+        expect { try CGRect.convert(from: [x]) }.to(throwError(errorType: Conversions.ConvertingException<CGRect>.self))
+        expect { try CGRect.convert(from: [x, y]) }.to(throwError(errorType: Conversions.ConvertingException<CGRect>.self))
+        expect { try CGRect.convert(from: [x, y, width, height, y]) }.to(throwError(errorType: Conversions.ConvertingException<CGRect>.self))
       }
 
       it("throws when dict is missing some keys") {
         expect { try CGRect.convert(from: ["x": x]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.MissingKeysError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.MissingKeysError<Double>(keys: ["y", "width", "height"]).description
+          expect($0).to(beAKindOf(Conversions.MissingKeysException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.MissingKeysException<Double>(["y", "width", "height"]).description
         })
       }
 
       it("throws when dict has uncastable keys") {
         expect { try CGRect.convert(from: ["x": x, "y": nil, "width": width, "height": "\(height)"]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.CastingValuesError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.CastingValuesError<Double>(keys: ["y", "height"]).description
+          expect($0).to(beAKindOf(Conversions.CastingValuesException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.CastingValuesException<Double>(["y", "height"]).description
         })
       }
     }
@@ -213,8 +213,8 @@ class ConvertiblesSpec: QuickSpec {
       }
       func testInvalidHexColor(_ hex: String) {
         expect { try CGColor.convert(from: hex) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.InvalidHexColorError.self))
-          expect(($0 as! CodedError).description) == Conversions.InvalidHexColorError(hex: hex).description
+          expect($0).to(beAKindOf(Conversions.InvalidHexColorException.self))
+          expect(($0 as! CodedError).description) == Conversions.InvalidHexColorException(hex).description
         })
       }
 
@@ -256,8 +256,8 @@ class ConvertiblesSpec: QuickSpec {
       it("throws when int overflows") {
         let hex = 0xBBAA88FF2
         expect { try CGColor.convert(from: hex) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.HexColorOverflowError.self))
-          expect(($0 as! CodedError).description) == Conversions.HexColorOverflowError(hex: UInt64(hex)).description
+          expect($0).to(beAKindOf(Conversions.HexColorOverflowException.self))
+          expect(($0 as! CodedError).description) == Conversions.HexColorOverflowException(UInt64(hex)).description
         })
       }
     }

package/ios/Tests/ExceptionsSpec.swift

@@ -0,0 +1,112 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+import Quick
+import Nimble
+
+@testable import ExpoModulesCore
+
+final class ExceptionsSpec: QuickSpec {
+  override func spec() {
+    it("has name") {
+      let error = TestException()
+      expect(error.name) == "TestException"
+    }
+
+    it("has code") {
+      let error = TestException()
+      expect(error.code) == "ERR_TEST"
+    }
+
+    it("has reason") {
+      let error = TestException()
+      expect(error.reason) == "This is the test exception"
+    }
+
+    it("can be chained once") {
+      func throwable() throws {
+        do {
+          throw TestExceptionCause()
+        } catch {
+          throw TestException().causedBy(error)
+        }
+      }
+      expect { try throwable() }.to(throwError { error in
+        testChainedExceptionTypes(error: error, types: [TestException.self, TestExceptionCause.self])
+      })
+    }
+
+    it("can be chained twice") {
+      func throwable() throws {
+        do {
+          do {
+            throw TestExceptionCause()
+          } catch {
+            throw TestExceptionCause().causedBy(error)
+          }
+        } catch {
+          throw TestException().causedBy(error)
+        }
+      }
+      expect { try throwable() }.to(throwError { error in
+        testChainedExceptionTypes(error: error, types: [TestException.self, TestExceptionCause.self, TestExceptionCause.self])
+      })
+    }
+
+    it("includes cause description") {
+      func throwable() throws {
+        do {
+          throw TestExceptionCause()
+        } catch {
+          throw TestException().causedBy(error)
+        }
+      }
+      expect { try throwable() }.to(throwError { error in
+        if let error = error as? TestException, let cause = error.cause as? TestExceptionCause {
+          expect(error.description).to(contain(cause.description))
+        } else {
+          fail("Error and its cause are not of expected types.")
+        }
+      })
+    }
+
+    it("has root cause") {
+      let a = TestException()
+      let b = TestException().causedBy(a)
+      let c = TestException().causedBy(b)
+
+      expect(c.rootCause) === a
+    }
+  }
+}
+
+class TestException: Exception {
+  override var reason: String {
+    "This is the test exception"
+  }
+}
+
+class TestExceptionCause: Exception {
+  override var reason: String {
+    "This is the cause of the test exception"
+  }
+}
+
+/**
+ Tests whether the exception chain matches given types and their order.
+ */
+private func testChainedExceptionTypes(error: Error, types: [Error.Type]) {
+  var next: Error? = error
+
+  for errorType in types {
+    let expectedErrorTypeName = String(describing: errorType)
+    let currentErrorTypeName = String(describing: type(of: next!))
+
+    expect(currentErrorTypeName).to(equal(expectedErrorTypeName), description: "The cause is not of type \(expectedErrorTypeName)")
+
+    if let chainableException = next as? ChainableException {
+      next = chainableException.cause
+    } else {
+      next = nil
+    }
+  }
+}

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.4",
+  "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": "81d318c3ac2db24ba192d2b3fc5a2dd1bbd8bd4d"
+  "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`
  */