Support new object construction

Author: kateinoigakukun

Diff for: src/swift/Sources/JavaScriptKit/JSFunction.swift

@@ -28,6 +28,21 @@ public class JSFunctionRef: Equatable {
         return result.jsValue()
     }
 
+    public func new(_ arguments: [JSValue]) -> JSObjectRef {
+        return arguments.withRawJSValues { rawValues in
+            rawValues.withUnsafeBufferPointer { bufferPointer in
+                let argv = bufferPointer.baseAddress
+                let argc = bufferPointer.count
+                var resultObj = JavaScriptPayload()
+                _call_new(
+                    self.id, argv, Int32(argc),
+                    &resultObj
+                )
+                return JSObjectRef(id: resultObj)
+            }
+        }
+    }
+
     static var sharedFunctions: [([JSValue]) -> JSValue] = []
     public static func from(_ body: @escaping ([JSValue]) -> JSValue) -> JSFunctionRef {
         let id = JavaScriptHostFuncRef(sharedFunctions.count)

Diff for: src/swift/Sources/JavaScriptKit/XcodeSupport.swift

@@ -39,5 +39,11 @@ func _call_function(
     _ result_kind: UnsafeMutablePointer<JavaScriptValueKind>!,
     _ result_payload1: UnsafeMutablePointer<JavaScriptPayload>!,
     _ result_payload2: UnsafeMutablePointer<JavaScriptPayload>!) { fatalError() }
-func _create_function(_ host_func_id: JavaScriptHostFuncRef, _ func_ref_ptr: UnsafePointer<JavaScriptObjectRef>!) {}
+func _call_new(
+    _ ref: JavaScriptObjectRef,
+    _ argv: UnsafePointer<RawJSValue>!, _ argc: Int32,
+    _ result_obj: UnsafeMutablePointer<JavaScriptPayload>!) { fatalError() }
+func _create_function(
+    _ host_func_id: JavaScriptHostFuncRef,
+    _ func_ref_ptr: UnsafePointer<JavaScriptObjectRef>!) { fatalError() }
 #endif

Diff for: src/swift/Sources/_CJavaScriptKit/include/_CJavaScriptKit.h

@@ -99,6 +99,16 @@ extern void _call_function(
     JavaScriptPayload *result_payload2
 );
 
+__attribute__((
+    __import_module__("javascript_kit"),
+    __import_name__("swjs_call_new")
+))
+extern void _call_new(
+    const JavaScriptObjectRef ref,
+    const RawJSValue *argv, const int argc,
+    JavaScriptPayload *result_obj
+);
+
 __attribute__((
     __import_module__("javascript_kit"),
     __import_name__("swjs_create_function")

Diff for: src/web/src/index.ts

@@ -290,6 +290,16 @@ export class SwiftRuntime {
                 })
                 writeUint32(func_ref_ptr, func_ref)
             },
+            swjs_call_new: (
+                ref: ref, argv: pointer, argc: number,
+                result_obj: pointer
+            ) => {
+                const obj = this._heapValues[ref]
+                const result = Reflect.construct(obj, decodeValues(argv, argc))
+                if (typeof result != "object")
+                    throw Error(`Invalid result type of object constructor of "${obj}": "${result}"`)
+                writeUint32(result_obj, allocValue(result));
+            },
         }
     }
 }

Diff for: test/JavaScriptKitExec/Sources/JavaScriptKitExec/main.swift

@@ -60,6 +60,8 @@ Object_Conversion: do {
         try expectEqual(actualElement, expectedElement)
     }
 
+    try expectEqual(getJSValue(this: globalObject1Ref, name: "undefined_prop"), .undefined)
+
 } catch {
     print(error)
 }
@@ -155,3 +157,28 @@ Host_Function_Registration: do {
 } catch {
     print(error)
 }
+
+New_Object_Construction: do {
+
+    // ```js
+    // global.Animal = function(name, age, isCat) {
+    //   this.name = name
+    //   this.age = age
+    //   this.bark = () => {
+    //     return isCat ? "nyan" : "wan"
+    //   }
+    // }
+    // ```
+    let objectConstructor = try expectFunction(getJSValue(this: .global(), name: "Animal"))
+    let cat1 = objectConstructor.new([.string("Tama"), .number(3), .boolean(true)])
+    try expectEqual(getJSValue(this: cat1, name: "name"), .string("Tama"))
+    try expectEqual(getJSValue(this: cat1, name: "age"), .number(3))
+    let cat1Bark = try expectFunction(getJSValue(this: cat1, name: "bark"))
+    try expectEqual(cat1Bark(), .string("nyan"))
+
+    let dog1 = objectConstructor.new([.string("Pochi"), .number(3), .boolean(false)])
+    let dog1Bark = try expectFunction(getJSValue(this: dog1, name: "bark"))
+    try expectEqual(dog1Bark(), .string("wan"))
+} catch {
+    print(error)
+}

Diff for: test/index.js

@@ -44,6 +44,14 @@ global.globalObject1 = {
   }
 }
 
+global.Animal = function(name, age, isCat) {
+  this.name = name
+  this.age = age
+  this.bark = () => {
+    return isCat ? "nyan" : "wan"
+  }
+}
+
 const startWasiTask = async () => {
   // Fetch our Wasm File
   const wasmBinary = await readFile("./dist/JavaScriptKitExec.wasm");