Support Dictionary and Array conversion

Author: kateinoigakukun

src/swift/Sources/JavaScriptKit/JSFunction.swift

@@ -30,7 +30,10 @@ public class JSFunctionRef: Equatable {
     }
 
     public func apply(this: JSObjectRef, arguments: JSValueConvertible...) -> JSValue {
-        let result = arguments.withRawJSValues { rawValues in
+        apply(this: this, argumentList: arguments)
+    }
+    public func apply(this: JSObjectRef, argumentList: [JSValueConvertible]) -> JSValue {
+        let result = argumentList.withRawJSValues { rawValues in
             rawValues.withUnsafeBufferPointer { bufferPointer -> RawJSValue in
                 let argv = bufferPointer.baseAddress
                 let argc = bufferPointer.count

src/swift/Sources/JavaScriptKit/JSObject.swift

@@ -7,8 +7,13 @@ public class JSObjectRef: Equatable {
         self.id = id
     }
 
-    public subscript(dynamicMember name: String) -> JSFunctionRef? {
-        get { self[dynamicMember: name].function }
+    public subscript(dynamicMember name: String) -> ((JSValueConvertible...) -> JSValue)? {
+        get {
+            guard let function = self[dynamicMember: name].function else { return nil }
+            return { (arguments: JSValueConvertible...) in
+                function.apply(this: self, argumentList: arguments)
+            }
+        }
     }
 
     public subscript(dynamicMember name: String) -> JSValue {

src/swift/Sources/JavaScriptKit/JSValue.swift

@@ -9,34 +9,34 @@ public enum JSValue: Equatable {
     case undefined
     case function(JSFunctionRef)
 
-    var boolean: Bool? {
+    public var boolean: Bool? {
         switch self {
         case let .boolean(boolean): return boolean
         default: return nil
         }
     }
 
-    var string: String? {
+    public var string: String? {
         switch self {
         case let .string(string): return string
         default: return nil
         }
     }
-    var number: Int32? {
+    public var number: Int32? {
         switch self {
         case let .number(number): return number
         default: return nil
         }
     }
-    var object: JSObjectRef? {
+    public var object: JSObjectRef? {
         switch self {
         case let .object(object): return object
         default: return nil
         }
     }
-    var isNull: Bool { return self == .null }
-    var isUndefined: Bool { return self == .undefined }
-    var function: JSFunctionRef? {
+    public var isNull: Bool { return self == .null }
+    public var isUndefined: Bool { return self == .undefined }
+    public var function: JSFunctionRef? {
         switch self {
         case let .function(function): return function
         default: return nil

src/swift/Sources/JavaScriptKit/JSValueConvertible.swift

@@ -20,9 +20,23 @@ extension String: JSValueConvertible {
     public func jsValue() -> JSValue { .string(self) }
 }
 
+extension JSObjectRef: JSValueConvertible {
+    public func jsValue() -> JSValue { .object(self) }
+}
+
+extension JSFunctionRef: JSValueConvertible {
+    public func jsValue() -> JSValue { .function(self) }
+}
+
 private let Object = JSObjectRef.global().Object.function!
 
-extension Dictionary: JSValueConvertible where Value: JSValueConvertible, Key == String {
+extension Dictionary where Value: JSValueConvertible, Key == String {
+    public func jsValue() -> JSValue {
+        Swift.Dictionary<Key, JSValueConvertible>.jsValue(self)()
+    }
+}
+
+extension Dictionary: JSValueConvertible where Value == JSValueConvertible, Key == String {
     public func jsValue() -> JSValue {
         let object = Object.new()
         for (key, value) in self {
@@ -34,11 +48,17 @@ extension Dictionary: JSValueConvertible where Value: JSValueConvertible, Key ==
 
 private let Array = JSObjectRef.global().Array.function!
 
-extension Array: JSValueConvertible where Element: JSValueConvertible {
+extension Array where Element: JSValueConvertible {
+    public func jsValue() -> JSValue {
+        Swift.Array<JSValueConvertible>.jsValue(self)()
+    }
+}
+
+extension Array: JSValueConvertible where Element == JSValueConvertible {
     public func jsValue() -> JSValue {
         let array = Array.new(count)
-        for element in self {
-            array.push!(element)
+        for (index, element) in self.enumerated() {
+            array[index] = element.jsValue()
         }
         return .object(array)
     }

test/JavaScriptKitExec/Sources/JavaScriptKitExec/main.swift

@@ -212,3 +212,35 @@ Call_Function_With_This: do {
 } catch {
     print(error)
 }
+
+Object_Conversion: do {
+    let array1 = [1, 2, 3]
+    let jsArray1 = array1.jsValue().object!
+    try expectEqual(jsArray1.length, .number(3))
+    try expectEqual(jsArray1[0], .number(1))
+    try expectEqual(jsArray1[1], .number(2))
+    try expectEqual(jsArray1[2], .number(3))
+
+    let array2: [JSValueConvertible] = [1, "str", false]
+    let jsArray2 = array2.jsValue().object!
+    try expectEqual(jsArray2.length, .number(3))
+    try expectEqual(jsArray2[0], .number(1))
+    try expectEqual(jsArray2[1], .string("str"))
+    try expectEqual(jsArray2[2], .boolean(false))
+    _ = jsArray2.push!(5)
+    try expectEqual(jsArray2.length, .number(4))
+    _ = jsArray2.push!(jsArray1)
+
+    // TODO: Object identity
+    // try expectEqual(jsArray2[4], .object(jsArray1))
+
+    let dict1: [String: JSValueConvertible] = [
+        "prop1": 1,
+        "prop2": "foo",
+    ]
+    let jsDict1 = dict1.jsValue().object!
+    try expectEqual(jsDict1.prop1, .number(1))
+    try expectEqual(jsDict1.prop2, .string("foo"))
+} catch {
+    print(error)
+}