expo-modules-core 1.2.6 → 1.3.0

package/ios/Tests/FunctionSpec.swift

@@ -128,11 +128,15 @@ class FunctionSpec: ExpoSpec {
 
         it("returns the record back (sync)") {
           let result = try Function(functionName) { (record: TestRecord) in record }
-            .call(by: nil, withArguments: [dict]) as? TestRecord.Dict
+            .call(by: nil, withArguments: [dict], appContext: appContext) as? TestRecord
+
+          guard let result = Conversions.convertFunctionResult(result, appContext: appContext) as? TestRecord.Dict else {
+            return fail()
+          }
 
           expect(result).notTo(beNil())
-          expect(result?["property"] as? String).to(equal(dict["property"]))
-          expect(result?["propertyWithCustomKey"] as? String).to(equal(dict["propertyWithCustomKey"]))
+          expect(result["property"] as? String).to(equal(dict["property"]))
+          expect(result["propertyWithCustomKey"] as? String).to(equal(dict["propertyWithCustomKey"]))
         }
 
         it("returns the record back (async)") {
@@ -186,11 +190,11 @@ class FunctionSpec: ExpoSpec {
           return returnedValue
         }
 
-        expect({ try fn.call(by: nil, withArguments: ["test"]) })
+        expect({ try fn.call(by: nil, withArguments: ["test"], appContext: appContext) })
           .notTo(throwError())
           .to(be(returnedValue))
 
-        expect({ try fn.call(by: nil, withArguments: ["test", 3]) })
+        expect({ try fn.call(by: nil, withArguments: ["test", 3], appContext: appContext) })
           .notTo(throwError())
           .to(be(returnedValue))
       }
@@ -200,7 +204,7 @@ class FunctionSpec: ExpoSpec {
           return "something"
         }
 
-        expect({ try fn.call(by: nil, withArguments: []) })
+        expect({ try fn.call(by: nil, withArguments: [], appContext: appContext) })
           .to(throwError(errorType: FunctionCallException.self) { error in
             expect(error.rootCause).to(beAKindOf(InvalidArgsNumberException.self))
             let exception = error.rootCause as! InvalidArgsNumberException
@@ -222,7 +226,8 @@ class FunctionSpec: ExpoSpec {
             switch result {
             case .failure(let error):
               expect(error).notTo(beNil())
-              expect(error).to(beAKindOf(ArgumentCastException.self))
+              expect(error).to(beAKindOf(FunctionCallException.self))
+              expect(error.isCausedBy(ArgumentCastException.self)) == true
               expect(error.isCausedBy(Conversions.CastingException<String>.self)) == true
             case .success(_):
               fail()
@@ -232,20 +237,20 @@ class FunctionSpec: ExpoSpec {
         }
       }
     }
-    
+
     context("JavaScript") {
-      let runtime = appContext.runtime
-      
+      let runtime = try! appContext.runtime
+
       beforeSuite {
         appContext.moduleRegistry.register(holder: mockModuleHolder(appContext) {
           Name("TestModule")
 
           Function("returnPi") { Double.pi }
-          
+
           Function("returnNull") { () -> Double? in
             return nil
           }
-          
+
           Function("isArgNull") { (arg: Double?) -> Bool in
             return arg == nil
           }
@@ -260,30 +265,41 @@ class FunctionSpec: ExpoSpec {
               }
             }
           }
+
+          Function("withFunction") { (fn: JavaScriptFunction<String>) -> String in
+            return try fn.call("foo", "bar")
+          }
         })
       }
 
       it("returns values") {
-        expect(try runtime?.eval("expo.modules.TestModule.returnPi()").asDouble()) == Double.pi
-        expect(try runtime?.eval("expo.modules.TestModule.returnNull()").isNull()) == true
+        expect(try runtime.eval("expo.modules.TestModule.returnPi()").asDouble()) == Double.pi
+        expect(try runtime.eval("expo.modules.TestModule.returnNull()").isNull()) == true
       }
 
       it("accepts optional arguments") {
-        expect(try runtime?.eval("expo.modules.TestModule.isArgNull(3.14)").asBool()) == false
-        expect(try runtime?.eval("expo.modules.TestModule.isArgNull(null)").asBool()) == true
+        expect(try runtime.eval("expo.modules.TestModule.isArgNull(3.14)").asBool()) == false
+        expect(try runtime.eval("expo.modules.TestModule.isArgNull(null)").asBool()) == true
       }
 
       it("returns object made from definition") {
         let initialValue = Int.random(in: 1..<100)
-        let object = try runtime?.eval("object = expo.modules.TestModule.returnObjectDefinition(\(initialValue))")
+        let object = try runtime.eval("object = expo.modules.TestModule.returnObjectDefinition(\(initialValue))")
+
+        expect(object.kind) == .object
+        expect(object.getObject().hasProperty("increment")) == true
 
-        expect(object?.kind) == .object
-        expect(object?.getObject().hasProperty("increment")) == true
+        let result = try runtime.eval("object.increment()")
+
+        expect(result.kind) == .number
+        expect(result.getInt()) == initialValue + 1
+      }
 
-        let result = try runtime?.eval("object.increment()")
+      it("takes JavaScriptFunction argument") {
+        let value = try runtime.eval("expo.modules.TestModule.withFunction((a, b) => a + b)")
 
-        expect(result?.kind) == .number
-        expect(result?.getInt()) == initialValue + 1
+        expect(value.kind) == .string
+        expect(value.getString()) == "foobar"
       }
     }
   }

package/ios/Tests/JavaScriptRuntimeSpec.swift

@@ -86,7 +86,11 @@ class JavaScriptRuntimeSpec: ExpoSpec {
       it("throws evaluation exception") {
         expect({ try runtime.eval("foo") }).to(throwError { error in
           expect(error).to(beAKindOf(JavaScriptEvalException.self))
+          #if canImport(reacthermes)
+          expect((error as! JavaScriptEvalException).reason).to(contain("Property 'foo' doesn't exist"))
+          #else
           expect((error as! JavaScriptEvalException).reason).to(contain("Can't find variable: foo"))
+          #endif
         })
       }
     }

package/ios/Tests/PropertyComponentSpec.swift

@@ -5,9 +5,12 @@ import ExpoModulesTestCore
 class PropertyComponentSpec: ExpoSpec {
   override func spec() {
     describe("property") {
+      let appContext = AppContext.create()
+      let runtime = try! appContext.runtime
+
       it("gets the value") {
         let property = Property("test") { return "expo" }
-        expect(try property.getValue()) == "expo"
+        expect(try property.getValue(appContext: appContext)) == "expo"
       }
 
       it("sets the value") {
@@ -19,39 +22,39 @@ class PropertyComponentSpec: ExpoSpec {
           }
 
         let newValue = Int.random(in: 0..<100)
-        property.setValue(newValue)
+        property.setValue(newValue, appContext: appContext)
 
-        expect(try property.getValue()) == value
+        expect(try property.getValue(appContext: appContext)) == value
         expect(value) == newValue
       }
     }
 
     describe("module property") {
       let appContext = AppContext.create()
-      let runtime = appContext.runtime
+      let runtime = try! appContext.runtime
 
       beforeSuite {
         appContext.moduleRegistry.register(moduleType: PropertyTestModule.self)
       }
 
       it("gets read-only property") {
-        let value = try runtime?.eval("expo.modules.PropertyTest.readOnly")
-        expect(value?.getString()) == "foo"
+        let value = try runtime.eval("expo.modules.PropertyTest.readOnly")
+        expect(value.getString()) == "foo"
       }
 
       it("gets writable property") {
-        let value = try runtime?.eval("expo.modules.PropertyTest.writable")
-        expect(value?.getInt()) == 444
+        let value = try runtime.eval("expo.modules.PropertyTest.writable")
+        expect(value.getInt()) == 444
       }
 
       it("sets writable property") {
-        try runtime?.eval("expo.modules.PropertyTest.writable = 777")
-        let value = try runtime?.eval("expo.modules.PropertyTest.writable")
-        expect(value?.getInt()) == 777
+        try runtime.eval("expo.modules.PropertyTest.writable = 777")
+        let value = try runtime.eval("expo.modules.PropertyTest.writable")
+        expect(value.getInt()) == 777
       }
 
       it("is enumerable") {
-        let keys = try runtime?.eval("Object.keys(expo.modules.PropertyTest)").getArray().map { $0.getString() } ?? []
+        let keys = try runtime.eval("Object.keys(expo.modules.PropertyTest)").getArray().map { $0.getString() } ?? []
         expect(keys).to(contain("readOnly", "writable", "undefined"))
       }
 
@@ -62,73 +65,73 @@ class PropertyComponentSpec: ExpoSpec {
 //      }
 
       it("returns undefined when getter is not specified") {
-        let value = try runtime?.eval("expo.modules.PropertyTest.undefined")
-        expect(value?.isUndefined()) == true
+        let value = try runtime.eval("expo.modules.PropertyTest.undefined")
+        expect(value.isUndefined()) == true
       }
     }
 
     describe("class property") {
       let appContext = AppContext.create()
-      let runtime = appContext.runtime
+      let runtime = try! appContext.runtime
 
       beforeSuite {
         appContext.moduleRegistry.register(moduleType: PropertyTestModule.self)
       }
 
       it("gets the value") {
-        let value = try runtime?.eval("new expo.modules.PropertyTest.TestClass().someValue")
+        let value = try runtime.eval("new expo.modules.PropertyTest.TestClass().someValue")
 
-        expect(value?.kind) == .number
-        expect(value?.getInt()) == TestClass.constantValue
+        expect(value.kind) == .number
+        expect(value.getInt()) == TestClass.constantValue
       }
 
       it("sets the value") {
         let newValue = Int.random(in: 1..<100)
-        let value = try runtime?.eval([
+        let value = try runtime.eval([
           "object = new expo.modules.PropertyTest.TestClass()",
           "object.someValue = \(newValue)",
           "object.someValue"
         ])
 
-        expect(value?.kind) == .number
-        expect(value?.getInt()) == newValue
+        expect(value.kind) == .number
+        expect(value.getInt()) == newValue
       }
 
       // Tests for accessing shared object properties through KeyPath and ReferenceWritableKeyPath
       describe("key path") {
         it("gets immutable property") {
-          let value = try runtime?.eval([
+          let value = try runtime.eval([
             "object = new expo.modules.PropertyTest.TestClass()",
             "object.immutableKeyPathProperty"
           ])
 
-          expect(value?.kind) == .number
-          expect(value?.getInt()) == TestClass.constantValue
+          expect(value.kind) == .number
+          expect(value.getInt()) == TestClass.constantValue
         }
 
         it("cannot set immutable property") {
           let newValue = Int.random(in: 100..<200)
-          let value = try runtime?.eval([
+          let value = try runtime.eval([
             "object = new expo.modules.PropertyTest.TestClass()",
             "object.immutableKeyPathProperty = \(newValue)",
             "object.immutableKeyPathProperty"
           ])
 
           // Returned value didn't change, it doesn't equal to `newValue`
-          expect(value?.kind) == .number
-          expect(value?.getInt()) == TestClass.constantValue
+          expect(value.kind) == .number
+          expect(value.getInt()) == TestClass.constantValue
         }
 
         it("sets mutable property") {
           let newValue = Int.random(in: 100..<200)
-          let value = try runtime?.eval([
+          let value = try runtime.eval([
             "object = new expo.modules.PropertyTest.TestClass()",
             "object.mutableKeyPathProperty = \(newValue)",
             "object.mutableKeyPathProperty"
           ])
 
-          expect(value?.kind) == .number
-          expect(value?.getInt()) == newValue
+          expect(value.kind) == .number
+          expect(value.getInt()) == newValue
         }
       }
     }

package/ios/Tests/RecordSpec.swift

@@ -4,9 +4,11 @@ import ExpoModulesTestCore
 
 class RecordSpec: ExpoSpec {
   override func spec() {
+    let appContext = AppContext.create()
+
     it("initializes with empty dictionary") {
       struct TestRecord: Record { }
-      _ = try TestRecord(from: [:])
+      _ = try TestRecord(from: [:], appContext: appContext)
     }
 
     it("works back and forth with a field") {
@@ -14,7 +16,7 @@ class RecordSpec: ExpoSpec {
         @Field var a: String?
       }
       let dict = ["a": "b"]
-      let record = try TestRecord(from: dict)
+      let record = try TestRecord(from: dict, appContext: appContext)
 
       expect(record.a).to(be(dict["a"]))
       expect(record.toDictionary()["a"]).to(be(dict["a"]))
@@ -25,7 +27,7 @@ class RecordSpec: ExpoSpec {
         @Field("key") var a: String?
       }
       let dict = ["key": "b"]
-      let record = try TestRecord(from: dict)
+      let record = try TestRecord(from: dict, appContext: appContext)
 
       expect(record.a).to(be(dict["key"]))
       expect(record.toDictionary()["key"]).to(be(dict["key"]))
@@ -36,7 +38,7 @@ class RecordSpec: ExpoSpec {
         @Field(.required) var a: Int
       }
 
-      expect { try TestRecord(from: [:]) }.to(throwError { error in
+      expect { try TestRecord(from: [:], appContext: appContext) }.to(throwError { error in
         expect(error).to(beAKindOf(FieldRequiredException.self))
       })
     }
@@ -47,7 +49,7 @@ class RecordSpec: ExpoSpec {
       }
       let dict = ["a": "try with String instead of Int"]
 
-      expect { try TestRecord(from: dict) }.to(throwError { error in
+      expect { try TestRecord(from: dict, appContext: appContext) }.to(throwError { error in
         expect(error).to(beAKindOf(FieldInvalidTypeException.self))
       })
     }

package/ios/Tests/SharedObjectRegistrySpec.swift

@@ -7,7 +7,7 @@ import ExpoModulesTestCore
 final class SharedObjectRegistrySpec: ExpoSpec {
   override func spec() {
     let appContext = AppContext.create()
-    let runtime = appContext.runtime
+    let runtime = try! appContext.runtime
 
     describe("pullNextId") {
       it("returns nextId") {
@@ -29,28 +29,28 @@ final class SharedObjectRegistrySpec: ExpoSpec {
     describe("add") {
       it("adds using nextId") {
         let nextId = SharedObjectRegistry.nextId
-        let id = SharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime!.createObject())
+        let id = SharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime.createObject())
         expect(nextId) == id
       }
       it("is increasing size") {
         let size = SharedObjectRegistry.size
-        SharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime!.createObject())
+        SharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime.createObject())
         expect(SharedObjectRegistry.size) == size + 1
       }
       it("assigns id on native object") {
         let nativeObject = TestSharedObject()
-        let id = SharedObjectRegistry.add(native: nativeObject, javaScript: runtime!.createObject())
+        let id = SharedObjectRegistry.add(native: nativeObject, javaScript: runtime.createObject())
         expect(nativeObject.sharedObjectId) == id
       }
       it("assigns id on JS object") {
-        let jsObject = runtime!.createObject()
+        let jsObject = runtime.createObject()
         let id = SharedObjectRegistry.add(native: TestSharedObject(), javaScript: jsObject)
         expect(jsObject.hasProperty(sharedObjectIdPropertyName)) == true
         expect(try! jsObject.getProperty(sharedObjectIdPropertyName).asInt()) == id
       }
       it("saves objects pair") {
         let nativeObject = TestSharedObject()
-        let jsObject = runtime!.createObject()
+        let jsObject = runtime.createObject()
         let id = SharedObjectRegistry.add(native: nativeObject, javaScript: jsObject)
         let pair = SharedObjectRegistry.get(id)
         expect(pair?.native) === nativeObject
@@ -60,18 +60,18 @@ final class SharedObjectRegistrySpec: ExpoSpec {
 
     describe("delete") {
       it("deletes objects pair") {
-        let id = SharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime!.createObject())
+        let id = SharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime.createObject())
         SharedObjectRegistry.delete(id)
         expect(SharedObjectRegistry.get(id)).to(beNil())
       }
       it("resets id on native object") {
         let nativeObject = TestSharedObject()
-        let id = SharedObjectRegistry.add(native: nativeObject, javaScript: runtime!.createObject())
+        let id = SharedObjectRegistry.add(native: nativeObject, javaScript: runtime.createObject())
         SharedObjectRegistry.delete(id)
         expect(nativeObject.sharedObjectId) == 0
       }
       it("resets id on JS object") {
-        let jsObject = runtime!.createObject()
+        let jsObject = runtime.createObject()
         let id = SharedObjectRegistry.add(native: TestSharedObject(), javaScript: jsObject)
         SharedObjectRegistry.delete(id)
         expect(try! jsObject.getProperty(sharedObjectIdPropertyName).asInt()) == 0
@@ -81,12 +81,12 @@ final class SharedObjectRegistrySpec: ExpoSpec {
     describe("toNativeObject") {
       it("returns native object") {
         let nativeObject = TestSharedObject()
-        let jsObject = runtime!.createObject()
+        let jsObject = runtime.createObject()
         SharedObjectRegistry.add(native: nativeObject, javaScript: jsObject)
         expect(SharedObjectRegistry.toNativeObject(jsObject)) === nativeObject
       }
       it("returns nil") {
-        let jsObject = runtime!.createObject()
+        let jsObject = runtime.createObject()
         expect(SharedObjectRegistry.toNativeObject(jsObject)).to(beNil())
       }
     }
@@ -94,7 +94,7 @@ final class SharedObjectRegistrySpec: ExpoSpec {
     describe("toJavaScriptObject") {
       it("returns JS object") {
         let nativeObject = TestSharedObject()
-        let jsObject = runtime!.createObject()
+        let jsObject = runtime.createObject()
         SharedObjectRegistry.add(native: nativeObject, javaScript: jsObject)
         expect(SharedObjectRegistry.toJavaScriptObject(nativeObject)) == jsObject
       }

package/ios/Tests/TypedArraysSpec.swift

@@ -8,7 +8,7 @@ final class TypedArraysSpec: ExpoSpec {
   override func spec() {
     describe("module") {
       let appContext = AppContext.create()
-      let runtime = appContext.runtime!
+      let runtime = try! appContext.runtime
 
       beforeSuite {
         appContext.moduleRegistry.register(moduleType: TypedArraysModule.self)

package/ios/Tests/ViewDefinitionSpec.swift

@@ -15,6 +15,8 @@ final class ViewDefinitionSpec: ExpoSpec {
     }
 
     describe("Prop") {
+      let appContext = AppContext.create()
+
       it("sets the prop") {
         let textView = UITextView()
         let content = "hello"
@@ -23,7 +25,7 @@ final class ViewDefinitionSpec: ExpoSpec {
             view.text = value
           }
         }
-        try definition.propsDict()["content"]?.set(value: content, onView: textView)
+        try definition.propsDict()["content"]?.set(value: content, onView: textView, appContext: appContext)
         expect(textView.text) == content
       }
 
@@ -36,7 +38,7 @@ final class ViewDefinitionSpec: ExpoSpec {
             expect(view).to(beAKindOf(UITextView.self))
           }
         }
-        try definition.propsDict()["content"]?.set(value: content, onView: textView)
+        try definition.propsDict()["content"]?.set(value: content, onView: textView, appContext: appContext)
       }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "1.2.6",
+  "version": "1.3.0",
   "description": "The core of Expo Modules architecture",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -42,5 +42,5 @@
     "@testing-library/react-hooks": "^7.0.1",
     "expo-module-scripts": "^3.0.0"
   },
-  "gitHead": "eaf0d87f56e17cb7162ccbd4f9ee29fb64dab810"
+  "gitHead": "4ba50c428c8369bb6b3a51a860d4898ad4ccbe78"
 }

package/src/NativeViewManagerAdapter.native.tsx

@@ -1,5 +1,7 @@
 import React from 'react';
-import { NativeModules, requireNativeComponent, HostComponent } from 'react-native';
+import { findNodeHandle, NativeModules, requireNativeComponent, HostComponent } from 'react-native';
+
+import { requireNativeModule } from './requireNativeModule';
 
 // To make the transition from React Native's `requireNativeComponent` to Expo's
 // `requireNativeViewManager` as easy as possible, `requireNativeViewManager` is a drop-in
@@ -10,10 +12,6 @@ import { NativeModules, requireNativeComponent, HostComponent } from 'react-nati
 // passed to React Native's View (ex: style, testID) and custom view props, which are passed to the
 // adapter view component in a prop called `proxiedProperties`.
 
-type NativeExpoComponentProps = {
-  proxiedProperties: object;
-};
-
 /**
  * A map that caches registered native components.
  */
@@ -52,33 +50,39 @@ export function requireNativeViewManager<P>(viewName: string): React.ComponentTy
   // Set up the React Native native component, which is an adapter to the universal module's view
   // manager
   const reactNativeViewName = `ViewManagerAdapter_${viewName}`;
-  const ReactNativeComponent =
-    requireCachedNativeComponent<NativeExpoComponentProps>(reactNativeViewName);
-  const proxiedPropsNames = viewManagerConfig?.propsNames ?? [];
+  const ReactNativeComponent = requireCachedNativeComponent(reactNativeViewName);
 
-  // Define a component for universal-module authors to access their native view manager
-  const NativeComponentAdapter = React.forwardRef<any>((props, ref) => {
-    const nativeProps = omit(props, proxiedPropsNames);
-    const proxiedProps = pick(props, proxiedPropsNames);
-    return <ReactNativeComponent {...nativeProps} proxiedProperties={proxiedProps} ref={ref} />;
-  }) as React.ComponentType<P>;
-  NativeComponentAdapter.displayName = `Adapter<${viewName}>`;
-  return NativeComponentAdapter;
-}
+  class NativeComponent extends React.PureComponent<P> {
+    static displayName = viewName;
+
+    // This will be accessed from native when the prototype functions are called,
+    // in order to find the associated native view.
+    nativeTag: number | null = null;
+
+    componentDidMount(): void {
+      this.nativeTag = findNodeHandle(this);
+    }
 
-function omit(props: Record<string, any>, propNames: string[]) {
-  const copied = { ...props };
-  for (const propName of propNames) {
-    delete copied[propName];
+    render(): React.ReactNode {
+      return <ReactNativeComponent {...this.props} />;
+    }
   }
-  return copied;
-}
 
-function pick(props: Record<string, any>, propNames: string[]) {
-  return propNames.reduce((prev, curr) => {
-    if (curr in props) {
-      prev[curr] = props[curr];
+  try {
+    const nativeModule = requireNativeModule(viewName);
+    const nativeViewPrototype = nativeModule.ViewPrototype;
+
+    if (nativeViewPrototype) {
+      // Assign native view functions to the component prototype so they can be accessed from the ref.
+      Object.assign(NativeComponent.prototype, nativeViewPrototype);
     }
-    return prev;
-  }, {});
+  } catch {
+    // `requireNativeModule` may throw an error when the native module cannot be found.
+    // In some tests we don't mock the entire modules, but we do want to mock native views. For now,
+    // until we still have to support the legacy modules proxy and don't have better ways to mock,
+    // let's just gracefully skip assigning the prototype functions.
+    // See: https://github.com/expo/expo/blob/main/packages/expo-modules-core/src/__tests__/NativeViewManagerAdapter-test.native.tsx
+  }
+
+  return NativeComponent;
 }

package/src/requireNativeModule.ts

@@ -34,8 +34,8 @@ declare global {
  */
 export function requireNativeModule<ModuleType = any>(moduleName: string): ModuleType {
   const nativeModule: ModuleType =
-    global.expo?.modules?.[moduleName] ??
-    global.ExpoModules?.[moduleName] ??
+    globalThis.expo?.modules?.[moduleName] ??
+    globalThis.ExpoModules?.[moduleName] ??
     NativeModulesProxy[moduleName];
 
   if (!nativeModule) {