expo-modules-core 0.7.0 → 0.9.1

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"
@@ -11,7 +10,7 @@ class FunctionSpec: QuickSpec {
     func testFunctionReturning<T: Equatable>(value returnValue: T) {
       waitUntil { done in
         mockModuleHolder(appContext) {
-          function(functionName) {
+          AsyncFunction(functionName) {
             return returnValue
           }
         }
@@ -27,7 +26,7 @@ class FunctionSpec: QuickSpec {
     it("is called") {
       waitUntil { done in
         mockModuleHolder(appContext) {
-          function(functionName) {
+          AsyncFunction(functionName) {
             done()
           }
         }
@@ -60,7 +59,7 @@ class FunctionSpec: QuickSpec {
       let str: String? = nil
 
       mockModuleHolder(appContext) {
-        function(functionName) { (a: String?) in
+        AsyncFunction(functionName) { (a: String?) in
           expect(a == nil) == true
         }
       }
@@ -71,7 +70,7 @@ class FunctionSpec: QuickSpec {
       let array: [[String]] = [["expo"]]
 
       mockModuleHolder(appContext) {
-        function(functionName) { (a: [[String]]) in
+        AsyncFunction(functionName) { (a: [[String]]) in
           expect(a.first!.first) == array.first!.first
         }
       }
@@ -92,7 +91,7 @@ class FunctionSpec: QuickSpec {
       it("converts to simple record when passed as an argument") {
         waitUntil { done in
           mockModuleHolder(appContext) {
-            function(functionName) { (a: TestRecord) in
+            AsyncFunction(functionName) { (a: TestRecord) in
               return a.property
             }
           }
@@ -108,7 +107,7 @@ class FunctionSpec: QuickSpec {
       it("converts to record with custom key") {
         waitUntil { done in
           mockModuleHolder(appContext) {
-            function(functionName) { (a: TestRecord) in
+            AsyncFunction(functionName) { (a: TestRecord) in
               return a.customKeyProperty
             }
           }
@@ -124,7 +123,7 @@ class FunctionSpec: QuickSpec {
       it("returns the record back") {
         waitUntil { done in
           mockModuleHolder(appContext) {
-            function(functionName) { (a: TestRecord) in
+            AsyncFunction(functionName) { (a: TestRecord) in
               return a.toDictionary()
             }
           }
@@ -145,15 +144,14 @@ class FunctionSpec: QuickSpec {
     it("throws when called with more arguments than expected") {
       waitUntil { done in
         mockModuleHolder(appContext) {
-          function(functionName) { (_: Int) in
+          AsyncFunction(functionName) { (_: Int) in
             return "something"
           }
         }
         // Function expects one argument, let's give it more.
         .call(function: functionName, args: [1, 2]) { _, error in
           expect(error).notTo(beNil())
-          expect(error).to(beAKindOf(FunctionCallException.self))
-          expect((error as! Exception).isCausedBy(InvalidArgsNumberException.self)) == true
+          expect(error).to(beAKindOf(InvalidArgsNumberException.self))
           done()
         }
       }
@@ -162,14 +160,14 @@ class FunctionSpec: QuickSpec {
     it("throws when called with arguments of incompatible types") {
       waitUntil { done in
         mockModuleHolder(appContext) {
-          function(functionName) { (_: String) in
+          AsyncFunction(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(FunctionCallException.self))
+          expect(error).to(beAKindOf(ArgumentCastException.self))
           expect((error as! Exception).isCausedBy(Conversions.CastingException<String>.self)) == true
           done()
         }

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"
@@ -18,7 +17,7 @@ class FunctionWithConvertiblesSpec: QuickSpec {
       let height = 592.1
 
       mockModuleHolder(appContext) {
-        function(functionName) { (point: CGPoint, size: CGSize, vector: CGVector, rect: CGRect) in
+        AsyncFunction(functionName) { (point: CGPoint, size: CGSize, vector: CGVector, rect: CGRect) in
           expect(point.x) == x
           expect(point.y) == y
           expect(size.width) == width
@@ -48,7 +47,7 @@ class FunctionWithConvertiblesSpec: QuickSpec {
       }
 
       mockModuleHolder(appContext) {
-        function(functionName) { (color1: CGColor, color2: CGColor, color3: CGColor, color4: CGColor) in
+        AsyncFunction(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/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!
 
@@ -19,22 +18,22 @@ class ModuleEventListenersSpec: QuickSpec {
       appContext = AppContext()
     }
 
-    it("calls onCreate once the module instance is created") {
+    it("calls OnCreate once the module instance is created") {
       waitUntil { done in
         _ = mockModuleHolder(appContext) {
-          $0.onCreate {
+          OnCreate {
             done()
           }
         }
       }
     }
 
-    it("calls onDestroy once the module is about to be deallocated") {
+    it("calls OnDestroy once the module is about to be deallocated") {
       waitUntil { done in
         let moduleName = "mockedModule"
         let holder = mockModuleHolder(appContext) {
-          $0.name(moduleName)
-          $0.onDestroy {
+          Name(moduleName)
+          OnDestroy {
             done()
           }
         }
@@ -45,10 +44,10 @@ class ModuleEventListenersSpec: QuickSpec {
       }
     }
 
-    it("calls onAppContextDestroys once the context destroys") {
+    it("calls OnAppContextDestroys once the context destroys") {
       waitUntil { done in
         let holder = mockModuleHolder(appContext) {
-          $0.onAppContextDestroys {
+          OnAppContextDestroys {
             done()
           }
         }
@@ -70,10 +69,10 @@ class ModuleEventListenersSpec: QuickSpec {
       }
     }
 
-    it("calls onAppEntersForeground when system's willEnterForegroundNotification is sent") {
+    it("calls OnAppEntersForeground when system's willEnterForegroundNotification is sent") {
       waitUntil { done in
         let holder = mockModuleHolder(appContext) {
-          $0.onAppEntersForeground {
+          OnAppEntersForeground {
             done()
           }
         }
@@ -82,10 +81,10 @@ class ModuleEventListenersSpec: QuickSpec {
       }
     }
 
-    it("calls onAppBecomesActive when system's didBecomeActiveNotification is sent") {
+    it("calls OnAppBecomesActive when system's didBecomeActiveNotification is sent") {
       waitUntil { done in
         let holder = mockModuleHolder(appContext) {
-          $0.onAppBecomesActive {
+          OnAppBecomesActive {
             done()
           }
         }
@@ -94,10 +93,10 @@ class ModuleEventListenersSpec: QuickSpec {
       }
     }
 
-    it("calls onAppEntersBackground when system's didEnterBackgroundNotification is sent") {
+    it("calls OnAppEntersBackground when system's didEnterBackgroundNotification is sent") {
       waitUntil { done in
         let holder = mockModuleHolder(appContext) {
-          $0.onAppEntersBackground {
+          OnAppEntersBackground {
             done()
           }
         }

package/ios/Tests/ModuleRegistrySpec.swift

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

package/ios/Tests/RecordSpec.swift

@@ -1,9 +1,8 @@
-import Quick
-import Nimble
+import ExpoModulesTestCore
 
 @testable import ExpoModulesCore
 
-class RecordSpec: QuickSpec {
+class RecordSpec: ExpoSpec {
   override func spec() {
     it("initializes with empty dictionary") {
       struct TestRecord: Record { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "0.7.0",
+  "version": "0.9.1",
   "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": "^2.0.0"
   },
-  "gitHead": "e1ff1a3d6bc62f374e6947a5e81428a1bb7cfa34"
+  "gitHead": "b9d655c1bed682ad8919e071dd923968773f05b5"
 }

package/src/NativeModulesProxy.native.ts

@@ -1,11 +1,6 @@
 import { NativeModules } from 'react-native';
 
-import { ProxyNativeModule, TurboNativeModuleProxy } from './NativeModulesProxy.types';
-
-// `ExpoModulesProxy` is not declared in TypeScript yet. It's installed via JSI.
-declare namespace global {
-  const ExpoModulesProxy: TurboNativeModuleProxy;
-}
+import { ProxyNativeModule } from './NativeModulesProxy.types';
 
 const NativeProxy = NativeModules.NativeUnimoduleProxy;
 const modulesConstantsKey = 'modulesConstants';
@@ -13,16 +8,6 @@ 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] || {};
@@ -38,12 +23,7 @@ if (NativeProxy) {
             )
           );
         }
-
-        if (canUseExpoTurboModules && global.ExpoModulesProxy) {
-          return global.ExpoModulesProxy.callMethodAsync(moduleName, methodInfo.name, args);
-        } else {
-          return NativeProxy.callMethod(moduleName, key, args);
-        }
+        return NativeProxy.callMethod(moduleName, key, args);
       };
     });
 

package/src/NativeModulesProxy.types.ts

@@ -3,11 +3,3 @@ 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/src/NativeViewManagerAdapter.native.tsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import { NativeModules, UIManager, ViewPropTypes, requireNativeComponent } from 'react-native';
+import { NativeModules, requireNativeComponent } from 'react-native';
 
 // To make the transition from React Native's `requireNativeComponent` to Expo's
 // `requireNativeViewManager` as easy as possible, `requireNativeViewManager` is a drop-in
@@ -10,11 +10,6 @@ import { NativeModules, UIManager, ViewPropTypes, requireNativeComponent } from
 // 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`.
 
-// NOTE: React Native is moving away from runtime PropTypes and may remove ViewPropTypes, in which
-// case we will need another way to separate standard React Native view props from other props,
-// which we proxy through the adapter
-const ViewPropTypesKeys = Object.keys(ViewPropTypes);
-
 type NativeExpoComponentProps = {
   proxiedProperties: object;
 };
@@ -23,14 +18,14 @@ type NativeExpoComponentProps = {
  * A drop-in replacement for `requireNativeComponent`.
  */
 export function requireNativeViewManager<P = any>(viewName: string): React.ComponentType<P> {
-  if (__DEV__) {
-    const { NativeUnimoduleProxy } = NativeModules;
-    if (!NativeUnimoduleProxy.viewManagersNames.includes(viewName)) {
-      const exportedViewManagerNames = NativeUnimoduleProxy.viewManagersNames.join(', ');
-      console.warn(
-        `The native view manager required by name (${viewName}) from NativeViewManagerAdapter isn't exported by expo-modules-core. Views of this type may not render correctly. Exported view managers: [${exportedViewManagerNames}].`
-      );
-    }
+  const { viewManagersMetadata } = NativeModules.NativeUnimoduleProxy;
+  const viewManagerConfig = viewManagersMetadata?.[viewName];
+
+  if (__DEV__ && !viewManagerConfig) {
+    const exportedViewManagerNames = Object.keys(viewManagersMetadata).join(', ');
+    console.warn(
+      `The native view manager required by name (${viewName}) from NativeViewManagerAdapter isn't exported by expo-modules-core. Views of this type may not render correctly. Exported view managers: [${exportedViewManagerNames}].`
+    );
   }
 
   // Set up the React Native native component, which is an adapter to the universal module's view
@@ -38,23 +33,12 @@ export function requireNativeViewManager<P = any>(viewName: string): React.Compo
   const reactNativeViewName = `ViewManagerAdapter_${viewName}`;
   const ReactNativeComponent =
     requireNativeComponent<NativeExpoComponentProps>(reactNativeViewName);
-  const reactNativeUIConfiguration = (UIManager.getViewManagerConfig
-    ? UIManager.getViewManagerConfig(reactNativeViewName)
-    : UIManager[reactNativeViewName]) || {
-    NativeProps: {},
-    directEventTypes: {},
-  };
-  const reactNativeComponentPropNames = [
-    'children',
-    ...ViewPropTypesKeys,
-    ...Object.keys(reactNativeUIConfiguration.NativeProps),
-    ...Object.keys(reactNativeUIConfiguration.directEventTypes),
-  ];
+  const proxiedPropsNames = viewManagerConfig?.propsNames ?? [];
 
   // Define a component for universal-module authors to access their native view manager
   function NativeComponentAdapter(props, ref) {
-    const nativeProps = pick(props, reactNativeComponentPropNames);
-    const proxiedProps = omit(props, reactNativeComponentPropNames);
+    const nativeProps = omit(props, proxiedPropsNames);
+    const proxiedProps = pick(props, proxiedPropsNames);
     return <ReactNativeComponent {...nativeProps} proxiedProperties={proxiedProps} ref={ref} />;
   }
   NativeComponentAdapter.displayName = `Adapter<${viewName}>`;

package/src/sweet/NativeErrorManager.ts

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

package/android/src/main/java/expo/modules/kotlin/events/KEventEmitterWrapper.kt

@@ -1,26 +0,0 @@
-package expo.modules.kotlin.events
-
-import android.os.Bundle
-import expo.modules.core.interfaces.services.EventEmitter
-import expo.modules.kotlin.ModuleHolder
-
-/**
- * In Swift, we check if the event is supported. Otherwise, we can't send such event through the bridge.
- * However, in Kotlin this is unnecessary, but to make our API consistent, we added similar check.
- * But because of that, we had to create a wrapper for EventEmitter.
- */
-class KEventEmitterWrapper(
-  private val moduleHolder: ModuleHolder,
-  private val legacyEventEmitter: EventEmitter
-) : EventEmitter by legacyEventEmitter {
-  override fun emit(eventName: String, eventBody: Bundle?) {
-    require(
-      moduleHolder
-        .definition
-        .eventsDefinition
-        ?.names
-        ?.contains(eventName) == true
-    ) { "Unsupported event: $eventName." }
-    legacyEventEmitter.emit(eventName, eventBody)
-  }
-}

package/android/src/main/java/expo/modules/kotlin/methods/Method.kt

@@ -1,14 +0,0 @@
-package expo.modules.kotlin.methods
-
-import expo.modules.kotlin.Promise
-import expo.modules.kotlin.types.AnyType
-
-class Method(
-  name: String,
-  argsType: Array<AnyType>,
-  private val body: (args: Array<out Any?>) -> Any?
-) : AnyMethod(name, argsType) {
-  override fun callImplementation(args: Array<out Any?>, promise: Promise) {
-    promise.resolve(body(args))
-  }
-}

package/android/src/main/java/expo/modules/kotlin/methods/PromiseMethod.kt

@@ -1,15 +0,0 @@
-package expo.modules.kotlin.methods
-
-import expo.modules.kotlin.Promise
-import expo.modules.kotlin.types.AnyType
-
-class PromiseMethod(
-  name: String,
-  argsType: Array<AnyType>,
-  private val body: (args: Array<out Any?>, promise: Promise) -> Unit
-) : AnyMethod(name, argsType) {
-
-  override fun callImplementation(args: Array<out Any?>, promise: Promise) {
-    body(args, promise)
-  }
-}