BridgeJS: Change @JS init to generate static init() methods instead of constructor in JS

CONTRIBUTING.md

@@ -71,6 +71,18 @@ Tests for `PackageToJS` plugin:
 swift test --package-path ./Plugins/PackageToJS
 ```
 
+Tests for `BridgeJS` plugin:
+
+```bash
+swift test --package-path ./Plugins/BridgeJS
+```
+
+To update snapshot test files when expected output changes:
+
+```bash
+UPDATE_SNAPSHOTS=1 swift test --package-path ./Plugins/BridgeJS
+```
+
 ### Editing `./Runtime` directory
 
 The `./Runtime` directory contains the JavaScript runtime that interacts with the JavaScript environment and Swift code.

Examples/ExportSwift/index.js

@@ -2,7 +2,7 @@ import { init } from "./.build/plugins/PackageToJS/outputs/Package/index.js";
 const { exports } = await init({});
 
 const Greeter = exports.Greeter;
-const greeter = new Greeter("World");
+const greeter = Greeter.init("World");
 const circle = exports.renderCircleSVG(100);
 
 // Display the results

Examples/PlayBridgeJS/Sources/JavaScript/app.js

@@ -52,7 +52,7 @@ export class BridgeJSPlayground {
                     createTS2Skeleton: this.createTS2Skeleton
                 }
             });
-            this.playBridgeJS = new exports.PlayBridgeJS();
+            this.playBridgeJS = exports.PlayBridgeJS.init();
             console.log('BridgeJS initialized successfully');
         } catch (error) {
             console.error('Failed to initialize BridgeJS:', error);
@@ -162,4 +162,4 @@ export class BridgeJSPlayground {
     hideError() {
         this.errorDisplay.classList.remove('show');
     }
-}
+}

Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSLink.swift

@@ -43,6 +43,10 @@ struct BridgeJSLink {
     let swiftHeapObjectClassJs = """
         /// Represents a Swift heap object like a class instance or an actor instance.
         class SwiftHeapObject {
+            static __construct(ptr, deinit) {
+                return new SwiftHeapObject(ptr, deinit);
+            }
+
             constructor(pointer, deinit) {
                 this.pointer = pointer;
                 this.hasReleased = false;
@@ -401,7 +405,7 @@ struct BridgeJSLink {
                 bodyLines.append("swift.memory.release(retId);")
                 returnExpr = "ret"
             case .swiftHeapObject(let name):
-                bodyLines.append("const ret = new \(name)(\(call));")
+                bodyLines.append("const ret = \(name).__construct(\(call));")
                 returnExpr = "ret"
             }
             return returnExpr
@@ -484,23 +488,37 @@ struct BridgeJSLink {
         dtsExportEntryLines.append("\(klass.name): {")
         jsLines.append("class \(klass.name) extends SwiftHeapObject {")
 
+        // Always add __construct and constructor methods for all classes
+        var constructorLines: [String] = []
+        constructorLines.append("static __construct(ptr) {")
+        constructorLines.append(
+            "return new \(klass.name)(ptr, instance.exports.bjs_\(klass.name)_deinit);".indent(count: 4)
+        )
+        constructorLines.append("}")
+        constructorLines.append("")
+        constructorLines.append("constructor(pointer, deinit) {")
+        constructorLines.append("super(pointer, deinit);".indent(count: 4))
+        constructorLines.append("}")
+        jsLines.append(contentsOf: constructorLines.map { $0.indent(count: 4) })
+
         if let constructor: ExportedConstructor = klass.constructor {
             let thunkBuilder = ExportedThunkBuilder(effects: constructor.effects)
             for param in constructor.parameters {
                 thunkBuilder.lowerParameter(param: param)
             }
             var funcLines: [String] = []
-            funcLines.append("constructor(\(constructor.parameters.map { $0.name }.joined(separator: ", "))) {")
+            funcLines.append("")
+            funcLines.append("static init(\(constructor.parameters.map { $0.name }.joined(separator: ", "))) {")
             let returnExpr = thunkBuilder.callConstructor(abiName: constructor.abiName)
             funcLines.append(contentsOf: thunkBuilder.bodyLines.map { $0.indent(count: 4) })
             funcLines.append(contentsOf: thunkBuilder.cleanupLines.map { $0.indent(count: 4) })
             funcLines.append(contentsOf: thunkBuilder.checkExceptionLines().map { $0.indent(count: 4) })
-            funcLines.append("super(\(returnExpr), instance.exports.bjs_\(klass.name)_deinit);".indent(count: 4))
+            funcLines.append("return \(klass.name).__construct(\(returnExpr));".indent(count: 4))
             funcLines.append("}")
             jsLines.append(contentsOf: funcLines.map { $0.indent(count: 4) })
 
             dtsExportEntryLines.append(
-                "new\(renderTSSignature(parameters: constructor.parameters, returnType: .swiftHeapObject(klass.name)));"
+                "init\(renderTSSignature(parameters: constructor.parameters, returnType: .swiftHeapObject(klass.name)));"
                     .indent(count: 4)
             )
         }

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Namespaces.Export.d.ts

@@ -51,10 +51,10 @@ export interface UUID extends SwiftHeapObject {
 }
 export type Exports = {
     Greeter: {
-        new(name: string): Greeter;
+        init(name: string): Greeter;
     }
     Converter: {
-        new(): Converter;
+        init(): Converter;
     }
     UUID: {
     }

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Namespaces.Export.js

@@ -60,6 +60,10 @@ export async function createInstantiator(options, swift) {
             const js = swift.memory.heap;
             /// Represents a Swift heap object like a class instance or an actor instance.
             class SwiftHeapObject {
+                static __construct(ptr, deinit) {
+                    return new SwiftHeapObject(ptr, deinit);
+                }
+
                 constructor(pointer, deinit) {
                     this.pointer = pointer;
                     this.hasReleased = false;
@@ -76,12 +80,20 @@ export async function createInstantiator(options, swift) {
                 }
             }
             class Greeter extends SwiftHeapObject {
-                constructor(name) {
+                static __construct(ptr) {
+                    return new Greeter(ptr, instance.exports.bjs_Greeter_deinit);
+                }
+
+                constructor(pointer, deinit) {
+                    super(pointer, deinit);
+                }
+
+                static init(name) {
                     const nameBytes = textEncoder.encode(name);
                     const nameId = swift.memory.retain(nameBytes);
                     const ret = instance.exports.bjs_Greeter_init(nameId, nameBytes.length);
                     swift.memory.release(nameId);
-                    super(ret, instance.exports.bjs_Greeter_deinit);
+                    return Greeter.__construct(ret);
                 }
                 greet() {
                     instance.exports.bjs_Greeter_greet(this.pointer);
@@ -91,9 +103,17 @@ export async function createInstantiator(options, swift) {
                 }
             }
             class Converter extends SwiftHeapObject {
-                constructor() {
+                static __construct(ptr) {
+                    return new Converter(ptr, instance.exports.bjs_Converter_deinit);
+                }
+
+                constructor(pointer, deinit) {
+                    super(pointer, deinit);
+                }
+
+                static init() {
                     const ret = instance.exports.bjs_Converter_init();
-                    super(ret, instance.exports.bjs_Converter_deinit);
+                    return Converter.__construct(ret);
                 }
                 toString(value) {
                     instance.exports.bjs_Converter_toString(this.pointer, value);
@@ -103,6 +123,13 @@ export async function createInstantiator(options, swift) {
                 }
             }
             class UUID extends SwiftHeapObject {
+                static __construct(ptr) {
+                    return new UUID(ptr, instance.exports.bjs_UUID_deinit);
+                }
+
+                constructor(pointer, deinit) {
+                    super(pointer, deinit);
+                }
                 uuidString() {
                     instance.exports.bjs_UUID_uuidString(this.pointer);
                     const ret = tmpRetString;

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/SwiftClass.Export.d.ts

@@ -17,7 +17,7 @@ export interface Greeter extends SwiftHeapObject {
 }
 export type Exports = {
     Greeter: {
-        new(name: string): Greeter;
+        init(name: string): Greeter;
     }
     takeGreeter(greeter: Greeter): void;
 }

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/SwiftClass.Export.js

@@ -60,6 +60,10 @@ export async function createInstantiator(options, swift) {
             const js = swift.memory.heap;
             /// Represents a Swift heap object like a class instance or an actor instance.
             class SwiftHeapObject {
+                static __construct(ptr, deinit) {
+                    return new SwiftHeapObject(ptr, deinit);
+                }
+
                 constructor(pointer, deinit) {
                     this.pointer = pointer;
                     this.hasReleased = false;
@@ -76,12 +80,20 @@ export async function createInstantiator(options, swift) {
                 }
             }
             class Greeter extends SwiftHeapObject {
-                constructor(name) {
+                static __construct(ptr) {
+                    return new Greeter(ptr, instance.exports.bjs_Greeter_deinit);
+                }
+
+                constructor(pointer, deinit) {
+                    super(pointer, deinit);
+                }
+
+                static init(name) {
                     const nameBytes = textEncoder.encode(name);
                     const nameId = swift.memory.retain(nameBytes);
                     const ret = instance.exports.bjs_Greeter_init(nameId, nameBytes.length);
                     swift.memory.release(nameId);
-                    super(ret, instance.exports.bjs_Greeter_deinit);
+                    return Greeter.__construct(ret);
                 }
                 greet() {
                     instance.exports.bjs_Greeter_greet(this.pointer);

Sources/JavaScriptKit/Documentation.docc/Articles/Exporting-Swift-to-JavaScript.md

@@ -133,7 +133,7 @@ In JavaScript:
 import { init } from "./.build/plugins/PackageToJS/outputs/Package/index.js";
 const { exports } = await init({});
 
-const cart = new exports.ShoppingCart();
+const cart = exports.ShoppingCart.init();
 cart.addItem("Laptop", 999.99, 1);
 cart.addItem("Mouse", 24.99, 2);
 console.log(`Items in cart: ${cart.getItemCount()}`);
@@ -158,7 +158,7 @@ export interface ShoppingCart extends SwiftHeapObject {
 
 export type Exports = {
     ShoppingCart: {
-        new(): ShoppingCart;
+        init(): ShoppingCart;
     }
 }
 ```
@@ -175,8 +175,8 @@ You can export functions to specific namespaces by providing a namespace paramet
 import JavaScriptKit
 
 // Export a function to a custom namespace
-@JS(namespace: "MyModule.Utils") func namespacedFunction() -> String { 
-    return "namespaced" 
+@JS(namespace: "MyModule.Utils") func namespacedFunction() -> String {
+    return "namespaced"
 }
 ```
 

Tests/BridgeJSRuntimeTests/ExportAPITests.swift

@@ -74,13 +74,47 @@ struct TestError: Error {
     g.changeName(name: name)
 }
 
+// Test class without @JS init constructor
+@JS class Calculator {
+    nonisolated(unsafe) static var onDeinit: () -> Void = {}
+
+    @JS func square(value: Int) -> Int {
+        return value * value
+    }
+
+    @JS func add(a: Int, b: Int) -> Int {
+        return a + b
+    }
+
+    deinit {
+        Self.onDeinit()
+    }
+}
+
+@JS func createCalculator() -> Calculator {
+    return Calculator()
+}
+
+@JS func useCalculator(calc: Calculator, x: Int, y: Int) -> Int {
+    return calc.add(a: calc.square(value: x), b: y)
+}
+
 class ExportAPITests: XCTestCase {
     func testAll() {
         var hasDeinitGreeter = false
+        var hasDeinitCalculator = false
+
         Greeter.onDeinit = {
             hasDeinitGreeter = true
         }
+
+        Calculator.onDeinit = {
+            hasDeinitCalculator = true
+        }
+
         runJsWorks()
-        XCTAssertTrue(hasDeinitGreeter)
+
+        XCTAssertTrue(hasDeinitGreeter, "Greeter (with @JS init) should have been deinitialized")
+        XCTAssertTrue(hasDeinitCalculator, "Calculator (without @JS init) should have been deinitialized")
     }
 }

Tests/BridgeJSRuntimeTests/Generated/BridgeJS.ExportSwift.swift

@@ -314,6 +314,28 @@ public func _bjs_takeGreeter(g: UnsafeMutableRawPointer, nameBytes: Int32, nameL
     #endif
 }
 
+@_expose(wasm, "bjs_createCalculator")
+@_cdecl("bjs_createCalculator")
+public func _bjs_createCalculator() -> UnsafeMutableRawPointer {
+    #if arch(wasm32)
+    let ret = createCalculator()
+    return Unmanaged.passRetained(ret).toOpaque()
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_useCalculator")
+@_cdecl("bjs_useCalculator")
+public func _bjs_useCalculator(calc: UnsafeMutableRawPointer, x: Int32, y: Int32) -> Int32 {
+    #if arch(wasm32)
+    let ret = useCalculator(calc: Unmanaged<Calculator>.fromOpaque(calc).takeUnretainedValue(), x: Int(x), y: Int(y))
+    return Int32(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
 @_expose(wasm, "bjs_Greeter_init")
 @_cdecl("bjs_Greeter_init")
 public func _bjs_Greeter_init(nameBytes: Int32, nameLen: Int32) -> UnsafeMutableRawPointer {
@@ -360,4 +382,32 @@ public func _bjs_Greeter_changeName(_self: UnsafeMutableRawPointer, nameBytes: I
 @_cdecl("bjs_Greeter_deinit")
 public func _bjs_Greeter_deinit(pointer: UnsafeMutableRawPointer) {
     Unmanaged<Greeter>.fromOpaque(pointer).release()
+}
+
+@_expose(wasm, "bjs_Calculator_square")
+@_cdecl("bjs_Calculator_square")
+public func _bjs_Calculator_square(_self: UnsafeMutableRawPointer, value: Int32) -> Int32 {
+    #if arch(wasm32)
+    let ret = Unmanaged<Calculator>.fromOpaque(_self).takeUnretainedValue().square(value: Int(value))
+    return Int32(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_Calculator_add")
+@_cdecl("bjs_Calculator_add")
+public func _bjs_Calculator_add(_self: UnsafeMutableRawPointer, a: Int32, b: Int32) -> Int32 {
+    #if arch(wasm32)
+    let ret = Unmanaged<Calculator>.fromOpaque(_self).takeUnretainedValue().add(a: Int(a), b: Int(b))
+    return Int32(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_Calculator_deinit")
+@_cdecl("bjs_Calculator_deinit")
+public func _bjs_Calculator_deinit(pointer: UnsafeMutableRawPointer) {
+    Unmanaged<Calculator>.fromOpaque(pointer).release()
 }