expo-modules-core 0.9.2 → 0.10.0

package/ios/Swift/TypedArrays/GenericTypedArray.swift

@@ -0,0 +1,49 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Generic TypedArray with an associated numeric ContentType (e.g. UInt8, Int16, Double).
+ */
+public class GenericTypedArray<ContentType: Numeric>: TypedArray {
+  /**
+   The unsafe mutable typed buffer that shares the same memory as the underlying JavaScript `ArrayBuffer`.
+   */
+  lazy var buffer = UnsafeMutableBufferPointer<ContentType>(start: pointer, count: length)
+
+  /**
+   The unsafe mutable typed pointer to the start of the array buffer.
+   */
+  lazy var pointer = rawPointer.bindMemory(to: ContentType.self, capacity: length)
+
+  public subscript(index: Int) -> ContentType {
+    get {
+      return buffer[index]
+    }
+    set {
+      buffer[index] = newValue
+    }
+  }
+
+  subscript(range: Range<Int>) -> [ContentType] {
+    get {
+      return Array(buffer[range])
+    }
+    set {
+      var newValues = newValue
+      newValues.withUnsafeMutableBufferPointer { newValuesBuffer in
+        buffer[range] = newValuesBuffer[0..<(range.upperBound - range.lowerBound)]
+      }
+    }
+  }
+
+  subscript(range: ClosedRange<Int>) -> [ContentType] {
+    get {
+      return Array(buffer[range])
+    }
+    set {
+      var newValues = newValue
+      newValues.withUnsafeMutableBufferPointer { newValuesBuffer in
+        buffer[range] = newValuesBuffer[0...(range.upperBound - range.lowerBound)]
+      }
+    }
+  }
+}

package/ios/Swift/TypedArrays/TypedArray.swift

@@ -0,0 +1,80 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ The base class for any type of the typed array.
+ */
+public class TypedArray: AnyTypedArray {
+  /**
+   Creates a concrete TypedArray from the given JavaScriptTypedArray
+   */
+  internal static func create(from jsTypedArray: JavaScriptTypedArray) -> TypedArray {
+    switch jsTypedArray.kind {
+    case .Int8Array:
+      return Int8Array(jsTypedArray)
+    case .Int16Array:
+      return Int16Array(jsTypedArray)
+    case .Int32Array:
+      return Int32Array(jsTypedArray)
+    case .Uint8Array:
+      return Uint8Array(jsTypedArray)
+    case .Uint8ClampedArray:
+      return Uint8ClampedArray(jsTypedArray)
+    case .Uint16Array:
+      return Uint16Array(jsTypedArray)
+    case .Uint32Array:
+      return Uint32Array(jsTypedArray)
+    case .Float32Array:
+      return Float32Array(jsTypedArray)
+    case .Float64Array:
+      return Float64Array(jsTypedArray)
+    case .BigInt64Array:
+      return BigInt64Array(jsTypedArray)
+    case .BigUint64Array:
+      return BigUint64Array(jsTypedArray)
+    @unknown default:
+      fatalError("Unknown kind of the TypedArray")
+    }
+  }
+
+  /**
+   A JavaScript object of the underlying typed array.
+   */
+  let jsTypedArray: JavaScriptTypedArray
+
+  /**
+   The length in bytes from the start of the underlying ArrayBuffer.
+   Fixed at construction time and thus read-only.
+   */
+  public lazy var byteLength: Int = jsTypedArray.getProperty("byteLength").getInt()
+
+  /**
+   The offset in bytes from the start of the underlying ArrayBuffer.
+   Fixed at construction time and thus read-only.
+   */
+  public lazy var byteOffset: Int = jsTypedArray.getProperty("byteOffset").getInt()
+
+  /**
+   Returns the number of elements held in the typed array.
+   Fixed at construction time and thus read only.
+   */
+  public lazy var length: Int = jsTypedArray.getProperty("length").getInt()
+
+  /**
+   The unsafe mutable raw pointer to the start of the array buffer.
+   */
+  public lazy var rawPointer: UnsafeMutableRawPointer = jsTypedArray.getUnsafeMutableRawPointer()
+
+  /**
+   Returns the kind of the typed array, such as `Int8Array` or `Float32Array`.
+   */
+  public var kind: TypedArrayKind {
+    return jsTypedArray.kind
+  }
+
+  /**
+   Initializes the typed array with the given JS typed array.
+   */
+  required init(_ jsTypedArray: JavaScriptTypedArray) {
+    self.jsTypedArray = jsTypedArray
+  }
+}

package/ios/Swift/Utilities.swift

@@ -0,0 +1,28 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Executes the given Swift closure and if it throws, the `NSError` is set on the given `NSErrorPointer` and the original error is rethrown.
+ This is especially useful for ObjC<->Swift interop, specifically when the ObjC needs to catch errors thrown by Swift closure.
+ */
+internal func runWithErrorPointer<R>(_ errorPointer: NSErrorPointer, _ closure: () throws -> R) rethrows -> R? {
+  do {
+    return try closure()
+  } catch {
+    errorPointer?.pointee = toNSError(error)
+    throw error
+  }
+}
+
+/**
+ Converts Swift errors to `NSError` so that they can be handled from the ObjC code.
+ */
+internal func toNSError(_ error: Error) -> NSError {
+  if let error = error as? Exception {
+    return NSError(domain: "dev.expo.modules", code: 0, userInfo: [
+      "name": error.name,
+      "code": error.code,
+      "message": error.debugDescription,
+    ])
+  }
+  return error as NSError
+}

package/ios/Swift/Views/ConcreteViewProp.swift

@@ -14,16 +14,16 @@ public final class ConcreteViewProp<ViewType: UIView, PropType: AnyArgument>: An
   public let name: String
 
   /**
-   An argument type wrapper for the prop's value type.
+   A dynamic type for the prop's value type.
    */
-  private let propType: AnyArgumentType
+  private let propType: AnyDynamicType
 
   /**
    Closure to call to set the actual property on the given view.
    */
   private let setter: SetterType
 
-  internal init(name: String, propType: AnyArgumentType, setter: @escaping SetterType) {
+  internal init(name: String, propType: AnyDynamicType, setter: @escaping SetterType) {
     self.name = name
     self.propType = propType
     self.setter = setter

package/ios/Swift/Views/ViewManagerDefinitionComponents.swift

@@ -29,7 +29,7 @@ public func prop<ViewType: UIView, PropType: AnyArgument>(
 ) -> ViewManagerDefinitionComponent {
   return ConcreteViewProp(
     name: name,
-    propType: ArgumentType(PropType.self),
+    propType: ~PropType.self,
     setter: setter
   )
 }
@@ -43,7 +43,7 @@ public func Prop<ViewType: UIView, PropType: AnyArgument>(
 ) -> ViewManagerDefinitionComponent {
   return ConcreteViewProp(
     name: name,
-    propType: ArgumentType(PropType.self),
+    propType: ~PropType.self,
     setter: setter
   )
 }

package/ios/Tests/ClassComponentSpec.swift

@@ -0,0 +1,210 @@
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+class ClassComponentSpec: ExpoSpec {
+  override func spec() {
+    describe("basic") {
+      it("factory returns a component") {
+        let klass = Class("") {}
+        expect(klass).to(beAnInstanceOf(ClassComponent.self))
+      }
+
+      it("has a name") {
+        let expoClassName = "ExpoClass"
+        let klass = Class(expoClassName) {}
+        expect(klass.name) == expoClassName
+      }
+
+      it("is without native constructor") {
+        let klass = Class("") {}
+        expect(klass.constructor).to(beNil())
+      }
+
+      it("has native constructor") {
+        let klass = Class("") { Constructor {} }
+        expect(klass.constructor).notTo(beNil())
+      }
+
+      it("ignores constructor as function") {
+        let klass = Class("") { Constructor {} }
+        expect(klass.functions["constructor"]).to(beNil())
+      }
+
+      it("builds a class") {
+        let runtime = JavaScriptRuntime()
+        let klass = Class("") {}
+        let object = klass.build(inRuntime: runtime)
+
+        expect(object.hasProperty("prototype")) == true
+        expect(object.getProperty("prototype").kind) == .object
+      }
+    }
+
+    describe("module") {
+      let appContext = AppContext.create()
+      let runtime = appContext.runtime
+
+      beforeSuite {
+        class ClassTestModule: Module {
+          func definition() -> ModuleDefinition {
+            Name("ClassTest")
+
+            Class("MyClass") {
+              Constructor {}
+
+              Function("myFunction") {
+                return "foobar"
+              }
+
+              Property("foo") {
+                return "bar"
+              }
+            }
+          }
+        }
+        appContext.moduleRegistry.register(moduleType: ClassTestModule.self)
+      }
+
+      it("is a function") {
+        let klass = try runtime?.eval("ExpoModules.ClassTest.MyClass")
+        expect(klass?.isFunction()) == true
+      }
+
+      it("has a name") {
+        let klass = try runtime?.eval("ExpoModules.ClassTest.MyClass.name")
+        expect(klass?.getString()) == "MyClass"
+      }
+
+      it("has a prototype") {
+        let prototype = try runtime?.eval("ExpoModules.ClassTest.MyClass.prototype")
+        expect(prototype?.isObject()) == true
+      }
+
+      it("has keys in prototype") {
+        let prototypeKeys = try runtime?.eval("Object.keys(ExpoModules.ClassTest.MyClass.prototype)")
+          .getArray()
+          .map { $0.getString() } ?? []
+
+        expect(prototypeKeys).to(contain("myFunction"))
+        expect(prototypeKeys).notTo(contain("__native_constructor__"))
+      }
+
+      it("is an instance of") {
+        let isInstanceOf = try runtime?.eval([
+          "myObject = new ExpoModules.ClassTest.MyClass()",
+          "myObject instanceof ExpoModules.ClassTest.MyClass",
+        ])
+
+        expect(isInstanceOf?.getBool()) == true
+      }
+
+      it("defines properties on initialization") {
+        // The properties are not specified in the prototype, but defined during initialization.
+        let object = try runtime?.eval("new ExpoModules.ClassTest.MyClass()").asObject()
+        expect(object?.getPropertyNames()).to(contain("foo"))
+        expect(object?.getProperty("foo").getString()) == "bar"
+      }
+    }
+
+    describe("class with associated type") {
+      let appContext = AppContext.create()
+      let runtime = appContext.runtime
+
+      beforeSuite {
+        appContext.moduleRegistry.register(moduleType: ModuleWithCounterClass.self)
+      }
+      it("is defined") {
+        let isDefined = try! runtime!.eval("'Counter' in ExpoModules.TestModule")
+
+        expect(isDefined.getBool()) == true
+      }
+      it("creates shared object") {
+        let jsObject = try! runtime!.eval("new ExpoModules.TestModule.Counter(0)").getObject()
+        let nativeObject = SharedObjectRegistry.toNativeObject(jsObject)
+
+        expect(nativeObject).notTo(beNil())
+      }
+      it("registers shared object") {
+        let oldSize = SharedObjectRegistry.size
+        try! runtime?.eval("object = new ExpoModules.TestModule.Counter(0)")
+
+        expect(SharedObjectRegistry.size) == oldSize + 1
+      }
+      it("calls function with owner") {
+        try runtime?.eval([
+          "object = new ExpoModules.TestModule.Counter(0)",
+          "object.increment(1)",
+        ])
+        // no expectations, just checking if it doesn't fail
+      }
+      it("creates with initial value") {
+        let initialValue = Int.random(in: 1..<100)
+        let value = try runtime!.eval([
+          "object = new ExpoModules.TestModule.Counter(\(initialValue))",
+          "object.getValue()",
+        ])
+
+        expect(value.kind) == .number
+        expect(value.getInt()) == initialValue
+      }
+      it("gets shared object value") {
+        let value = try runtime!.eval([
+          "object = new ExpoModules.TestModule.Counter(0)",
+          "object.getValue()",
+        ])
+
+        expect(value.kind) == .number
+        expect(value.isNumber()) == true
+      }
+      it("changes shared object") {
+        try! runtime?.eval("object = new ExpoModules.TestModule.Counter(0)")
+        let incrementBy = Int.random(in: 1..<100)
+        let value = try runtime!.eval("object.getValue()").asInt()
+        let newValue = try runtime!.eval([
+          "object.increment(\(incrementBy))",
+          "object.getValue()",
+        ])
+
+        expect(newValue.kind) == .number
+        expect(newValue.getInt()) == value + incrementBy
+      }
+    }
+  }
+}
+
+/**
+ A module that exposes a Counter class with an associated shared object class.
+ */
+fileprivate final class ModuleWithCounterClass: Module {
+  func definition() -> ModuleDefinition {
+    Name("TestModule")
+
+    Class(Counter.self) {
+      Constructor { (initialValue: Int) in
+        return Counter(initialValue: initialValue)
+      }
+      Function("increment") { (counter, value: Int) in
+        counter.increment(by: value)
+      }
+      Function("getValue") { counter in
+        return counter.currentValue
+      }
+    }
+  }
+}
+
+/**
+ A shared object class that stores some native value and can be used as an associated type of the JS class.
+ */
+fileprivate final class Counter: SharedObject {
+  var currentValue = 0
+
+  init(initialValue: Int = 0) {
+    self.currentValue = initialValue
+  }
+
+  func increment(by value: Int = 1) {
+    currentValue += value
+  }
+}