expo-modules-core 1.0.4 → 1.1.0

package/ios/Tests/FunctionSpec.swift

@@ -179,6 +179,37 @@ class FunctionSpec: ExpoSpec {
         }
       }
 
+      it("allows to skip trailing optional arguments") {
+        let returnedValue = "something"
+        let fn = Function(functionName) { (a: String, b: Int?, c: Bool?) in
+          expect(c).to(beNil())
+          return returnedValue
+        }
+
+        expect({ try fn.call(by: nil, withArguments: ["test"]) })
+          .notTo(throwError())
+          .to(be(returnedValue))
+
+        expect({ try fn.call(by: nil, withArguments: ["test", 3]) })
+          .notTo(throwError())
+          .to(be(returnedValue))
+      }
+
+      it("throws when called without required arguments") {
+        let fn = Function(functionName) { (requiredArgument: String, optionalArgument: Int?) in
+          return "something"
+        }
+
+        expect({ try fn.call(by: nil, withArguments: []) })
+          .to(throwError(errorType: FunctionCallException.self) { error in
+            expect(error.rootCause).to(beAKindOf(InvalidArgsNumberException.self))
+            let exception = error.rootCause as! InvalidArgsNumberException
+            expect(exception.param.received) == 0
+            expect(exception.param.required) == 1
+            expect(exception.param.expected) == 2
+          })
+      }
+
       it("throws when called with arguments of incompatible types") {
         waitUntil { done in
           mockModuleHolder(appContext) {

package/ios/Tests/PropertyComponentSpec.swift

@@ -7,7 +7,7 @@ class PropertyComponentSpec: ExpoSpec {
     describe("property") {
       it("gets the value") {
         let property = Property("test") { return "expo" }
-        expect(property.getValue()) == "expo"
+        expect(try property.getValue()) == "expo"
       }
 
       it("sets the value") {
@@ -21,7 +21,7 @@ class PropertyComponentSpec: ExpoSpec {
         let newValue = Int.random(in: 0..<100)
         property.setValue(newValue)
 
-        expect(property.getValue()) == value
+        expect(try property.getValue()) == value
         expect(value) == newValue
       }
     }
@@ -31,32 +31,6 @@ class PropertyComponentSpec: ExpoSpec {
       let runtime = appContext.runtime
 
       beforeSuite {
-        class PropertyTestModule: Module {
-          func definition() -> ModuleDefinition {
-            Name("PropertyTest")
-
-            Property("readOnly") {
-              return "foo"
-            }
-
-            var writablePropertyValue = 444
-            Property("writable")
-              .get {
-                return writablePropertyValue
-              }
-              .set { value in
-                writablePropertyValue = value
-              }
-
-            Property("withCaller") { (caller: JavaScriptObject) -> String in
-              // Here, the caller is a JS object of the module.
-              // Return another property of itself.
-              return caller.getProperty("readOnly").getString()
-            }
-
-            Property("undefined")
-          }
-        }
         appContext.moduleRegistry.register(moduleType: PropertyTestModule.self)
       }
 
@@ -78,18 +52,142 @@ class PropertyComponentSpec: ExpoSpec {
 
       it("is enumerable") {
         let keys = try runtime?.eval("Object.keys(expo.modules.PropertyTest)").getArray().map { $0.getString() } ?? []
-        expect(keys).to(contain("readOnly", "writable", "withCaller", "undefined"))
+        expect(keys).to(contain("readOnly", "writable", "undefined"))
       }
 
-      it("is called with the caller") {
-        let value = try runtime?.eval("expo.modules.PropertyTest.withCaller")
-        expect(value?.getString()) == "foo"
-      }
+// TODO: Using JavaScriptObject as the owner is no longer possible, but we may want to bring this feature back
+//      it("is called with the caller") {
+//        let value = try runtime?.eval("expo.modules.PropertyTest.withCaller")
+//        expect(value?.getString()) == "foo"
+//      }
 
       it("returns undefined when getter is not specified") {
         let value = try runtime?.eval("expo.modules.PropertyTest.undefined")
         expect(value?.isUndefined()) == true
       }
     }
+
+    describe("class property") {
+      let appContext = AppContext.create()
+      let runtime = appContext.runtime
+
+      beforeSuite {
+        appContext.moduleRegistry.register(moduleType: PropertyTestModule.self)
+      }
+
+      it("gets the value") {
+        let value = try runtime?.eval("new expo.modules.PropertyTest.TestClass().someValue")
+
+        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([
+          "object = new expo.modules.PropertyTest.TestClass()",
+          "object.someValue = \(newValue)",
+          "object.someValue"
+        ])
+
+        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([
+            "object = new expo.modules.PropertyTest.TestClass()",
+            "object.immutableKeyPathProperty"
+          ])
+
+          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([
+            "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
+        }
+
+        it("sets mutable property") {
+          let newValue = Int.random(in: 100..<200)
+          let value = try runtime?.eval([
+            "object = new expo.modules.PropertyTest.TestClass()",
+            "object.mutableKeyPathProperty = \(newValue)",
+            "object.mutableKeyPathProperty"
+          ])
+
+          expect(value?.kind) == .number
+          expect(value?.getInt()) == newValue
+        }
+      }
+    }
   }
 }
+
+class PropertyTestModule: Module {
+  func definition() -> ModuleDefinition {
+    Name("PropertyTest")
+
+    Property("readOnly") {
+      return "foo"
+    }
+
+    var writablePropertyValue = 444
+    Property("writable")
+      .get {
+        return writablePropertyValue
+      }
+      .set { value in
+        writablePropertyValue = value
+      }
+
+// TODO: Using JavaScriptObject as the owner is no longer possible, but we may want to bring this feature back
+//            Property("withCaller") { (caller: JavaScriptObject) -> String in
+//              // Here, the caller is a JS object of the module.
+//              // Return another property of itself.
+//              return caller.getProperty("readOnly").getString()
+//            }
+
+    Property("undefined")
+
+    Class(TestClass.self) {
+      Constructor {
+        return TestClass()
+      }
+
+      Property("someValue") { object in
+        return object.someValue
+      }
+      .set { object, newValue in
+        object.someValue = newValue
+      }
+
+      // KeyPath<TestClass, Int>
+      Property("immutableKeyPathProperty", \.immutableKeyPathProperty)
+
+      // ReferenceWritableKeyPath<TestClass, Int>
+      Property("mutableKeyPathProperty", \.mutableKeyPathProperty)
+    }
+  }
+}
+
+fileprivate final class TestClass: SharedObject {
+  static let constantValue = Int.random(in: 1..<100)
+
+  var someValue = TestClass.constantValue
+
+  // For "key path" tests
+  let immutableKeyPathProperty = TestClass.constantValue
+  var mutableKeyPathProperty = TestClass.constantValue
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "1.0.4",
+  "version": "1.1.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": "a4a37bbc631362ec2a6d83eb6361d5059bbc67da"
+  "gitHead": "ba80e8181b79d06e00a245653727f4eaeb80420e"
 }

package/src/NativeViewManagerAdapter.native.tsx

@@ -17,7 +17,7 @@ type NativeExpoComponentProps = {
 /**
  * A drop-in replacement for `requireNativeComponent`.
  */
-export function requireNativeViewManager<P = any>(viewName: string): React.ComponentType<P> {
+export function requireNativeViewManager<P>(viewName: string): React.ComponentType<P> {
   const { viewManagersMetadata } = NativeModules.NativeUnimoduleProxy;
   const viewManagerConfig = viewManagersMetadata?.[viewName];
 
@@ -36,13 +36,13 @@ export function requireNativeViewManager<P = any>(viewName: string): React.Compo
   const proxiedPropsNames = viewManagerConfig?.propsNames ?? [];
 
   // Define a component for universal-module authors to access their native view manager
-  function NativeComponentAdapter(props, ref) {
+  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 React.forwardRef(NativeComponentAdapter);
+  return NativeComponentAdapter;
 }
 
 function omit(props: Record<string, any>, propNames: string[]) {

package/src/TypedArrays.types.ts

@@ -0,0 +1,11 @@
+/** A union type for all integer based [`TypedArray` objects](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#typedarray_objects). */
+export type IntBasedTypedArray = Int8Array | Int16Array | Int32Array;
+
+/** A union type for all unsigned integer based [`TypedArray` objects](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#typedarray_objects). */
+export type UintBasedTypedArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;
+
+/** A union type for all floating point based [`TypedArray` objects](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#typedarray_objects). */
+export type FloatBasedTypedArray = Float32Array | Float64Array;
+
+/** A [`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) describes an array-like view of an underlying binary data buffer. */
+export type TypedArray = IntBasedTypedArray | UintBasedTypedArray | FloatBasedTypedArray;

package/src/index.ts

@@ -28,6 +28,7 @@ export {
 };
 
 export * from './requireNativeModule';
+export * from './TypedArrays.types';
 
 /**
  * @deprecated renamed to `DeviceEventEmitter`

package/ios/AppDelegates/EXAppDelegateWrapper.m

@@ -1,45 +0,0 @@
-// Copyright 2018-present 650 Industries. All rights reserved.
-
-#import <ExpoModulesCore/EXAppDelegateWrapper.h>
-#import <ExpoModulesCore/EXReactDelegateWrapper+Private.h>
-#import <ExpoModulesCore/Swift.h>
-
-
-@interface EXAppDelegateWrapper()
-
-@property (nonatomic, strong) EXReactDelegateWrapper *reactDelegate;
-
-@end
-
-@implementation EXAppDelegateWrapper {
-  EXExpoAppDelegate *_expoAppDelegate;
-}
-
-// Synthesize window, so the AppDelegate can synthesize it too.
-@synthesize window = _window;
-
-- (instancetype)init
-{
-  if (self = [super init]) {
-    _expoAppDelegate = [[EXExpoAppDelegate alloc] init];
-    _reactDelegate = [[EXReactDelegateWrapper alloc] initWithExpoReactDelegate:_expoAppDelegate.reactDelegate];
-  }
-  return self;
-}
-
-// This needs to be implemented, otherwise forwarding won't be called.
-// When the app starts, `UIApplication` uses it to check beforehand
-// which `UIApplicationDelegate` selectors are implemented.
-- (BOOL)respondsToSelector:(SEL)selector
-{
-  return [super respondsToSelector:selector]
-    || [_expoAppDelegate respondsToSelector:selector];
-}
-
-// Forwards all invocations to `ExpoAppDelegate` object.
-- (id)forwardingTargetForSelector:(SEL)selector
-{
-  return _expoAppDelegate;
-}
-
-@end