feat: expose namespaces to JS and add JS / TS code generation

Author: krodak

Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSLink.swift

@@ -62,6 +62,7 @@ struct BridgeJSLink {
         var classLines: [String] = []
         var dtsExportLines: [String] = []
         var dtsClassLines: [String] = []
+        var namespacedFunctions: [ExportedFunction] = []
 
         if exportedSkeletons.contains(where: { $0.classes.count > 0 }) {
             classLines.append(
@@ -87,9 +88,15 @@ struct BridgeJSLink {
 
             for function in skeleton.functions {
                 var (js, dts) = renderExportedFunction(function: function)
+                
+                if function.namespace != nil {
+                    namespacedFunctions.append(function)
+                }
+                
                 js[0] = "\(function.name): " + js[0]
                 js[js.count - 1] += ","
                 exportsLines.append(contentsOf: js)
+                
                 dtsExportLines.append(contentsOf: dts)
             }
         }
@@ -108,6 +115,33 @@ struct BridgeJSLink {
             importObjectBuilders.append(importObjectBuilder)
         }
 
+        let hasNamespacedFunctions = !namespacedFunctions.isEmpty
+
+        let exportsSection: String
+        if hasNamespacedFunctions {
+            let setupLines = renderGlobalNamespace(namespacedFunctions: namespacedFunctions)
+            let namespaceSetupCode = setupLines.map { $0.indent(count: 12) }.joined(separator: "\n")
+            exportsSection = """
+            \(classLines.map { $0.indent(count: 12) }.joined(separator: "\n"))
+                        const exports = {
+            \(exportsLines.map { $0.indent(count: 16) }.joined(separator: "\n"))
+                        };
+            
+            \(namespaceSetupCode)
+            
+                        return exports;
+                    },
+            """
+        } else {
+            exportsSection = """
+            \(classLines.map { $0.indent(count: 12) }.joined(separator: "\n"))
+                        return {
+            \(exportsLines.map { $0.indent(count: 16) }.joined(separator: "\n"))
+                        };
+                    },
+            """
+        }
+
         let outputJs = """
             // NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
             // DO NOT EDIT.
@@ -169,15 +203,67 @@ struct BridgeJSLink {
                     /** @param {WebAssembly.Instance} instance */
                     createExports: (instance) => {
                         const js = swift.memory.heap;
-            \(classLines.map { $0.indent(count: 12) }.joined(separator: "\n"))
-                        return {
-            \(exportsLines.map { $0.indent(count: 16) }.joined(separator: "\n"))
-                        };
-                    },
+                    \(exportsSection)
                 }
             }
             """
+        
+        // Collect namespace declarations for TypeScript
+        var namespaceDeclarations: [String: [(name: String, parameters: [Parameter], returnType: BridgeType)]] = [:]
+        
+        for skeleton in exportedSkeletons {
+            for function in skeleton.functions {
+                if let namespace = function.namespace {
+                    let namespaceKey = namespace.joined(separator: ".")
+                    if namespaceDeclarations[namespaceKey] == nil {
+                        namespaceDeclarations[namespaceKey] = []
+                    }
+                    namespaceDeclarations[namespaceKey]?.append((function.name, function.parameters, function.returnType))
+                }
+            }
+        }
+        
+        // Generate namespace declarations in TypeScript
         var dtsLines: [String] = []
+        
+        // Only add export {} and declare global block if we have namespace declarations
+        let hasNamespaceDeclarations = !namespaceDeclarations.isEmpty
+        
+        if hasNamespaceDeclarations {
+            dtsLines.append("export {};")
+            dtsLines.append("")
+            dtsLines.append("declare global {")
+        }
+        
+        // Generate namespace structure using nested declarations
+        for (namespacePath, functions) in namespaceDeclarations.sorted(by: { $0.key < $1.key }) {
+            let parts = namespacePath.split(separator: ".").map(String.init)
+            
+            // Open namespaces with proper indentation
+            for i in 0..<parts.count {
+                dtsLines.append("namespace \(parts[i]) {".indent(count: 4*(hasNamespaceDeclarations ? i + 1: 1)) )
+            }
+            
+            // Add function signatures with proper indentation
+            let functionIndentationLevel = hasNamespaceDeclarations ? parts.count + 1 : parts.count
+            for (name, parameters, returnType) in functions {
+                let signature = "function \(name)\(renderTSSignature(parameters: parameters, returnType: returnType));"
+                dtsLines.append("\(signature)".indent(count: 4*functionIndentationLevel))
+            }
+            
+            // Close namespaces with proper indentation (in reverse order)
+            for i in (0..<parts.count).reversed() {
+                let indentationLevel = hasNamespaceDeclarations ? i + 1 : i
+                dtsLines.append("}".indent(count: 4*indentationLevel))
+            }
+        }
+        
+        if hasNamespaceDeclarations {
+            dtsLines.append("}")
+            dtsLines.append("")
+        }
+        
+        // Add remaining class lines
         dtsLines.append(contentsOf: dtsClassLines)
         dtsLines.append("export type Exports = {")
         dtsLines.append(contentsOf: dtsExportLines.map { $0.indent(count: 4) })
@@ -395,6 +481,47 @@ struct BridgeJSLink {
 
         return (jsLines, dtsTypeLines, dtsExportEntryLines)
     }
+    
+    // __Swift.Foundation.UUID
+    
+    // [__Swift, Foundation, UUID]
+    // [[__Swift, Foundation, UUID], [__Swift, Foundation]]
+    
+    // __Swift
+    // __Swift.Foundation
+    // __Swift.Foundation.UUID
+    
+    func renderGlobalNamespace(namespacedFunctions: [ExportedFunction]) -> [String] {
+        var lines: [String] = []
+        var uniqueNamespaces: [String] = []
+        
+        var namespacePaths: Set<[String]> = Set(namespacedFunctions
+            .compactMap { $0.namespace })
+
+        namespacePaths.forEach { namespacePath in
+            namespacePath.makeIterator().enumerated().forEach { (index, element) in
+                let path = namespacePath[0...index].joined(separator: ".")
+                if !uniqueNamespaces.contains(path) {
+                    uniqueNamespaces.append(path)
+                }
+            }
+        }
+        
+        uniqueNamespaces.map { namespace in
+            lines.append("if (typeof globalThis.\(namespace) === 'undefined') {")
+            lines.append("    globalThis.\(namespace) = {};")
+            lines.append("}")
+        }
+
+        for function in namespacedFunctions {
+            if let namespace = function.namespace {
+                let namespacePath = namespace.joined(separator: ".")
+                lines.append("globalThis.\(namespacePath).\(function.name) = exports.\(function.name);")
+            }
+        }
+        
+        return lines
+    }
 
     class ImportedThunkBuilder {
         var bodyLines: [String] = []

Plugins/BridgeJS/Sources/BridgeJSSkeleton/BridgeJSSkeleton.swift

@@ -29,12 +29,14 @@ struct ExportedFunction: Codable {
     var parameters: [Parameter]
     var returnType: BridgeType
     var effects: Effects
+    var namespace: [String]?
 }
 
 struct ExportedClass: Codable {
     var name: String
     var constructor: ExportedConstructor?
     var methods: [ExportedFunction]
+    var namespace: [String]?
 }
 
 struct ExportedConstructor: Codable {

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Interface.Import.js.actual

@@ -0,0 +1,94 @@
+// NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
+// DO NOT EDIT.
+//
+// To update this file, just rebuild your project or run
+// `swift package bridge-js`.
+
+export async function createInstantiator(options, swift) {
+    let instance;
+    let memory;
+    let setException;
+    const textDecoder = new TextDecoder("utf-8");
+    const textEncoder = new TextEncoder("utf-8");
+
+    let tmpRetString;
+    let tmpRetBytes;
+    let tmpRetException;
+    return {
+        /** @param {WebAssembly.Imports} importObject */
+        addImports: (importObject) => {
+            const bjs = {};
+            importObject["bjs"] = bjs;
+            bjs["swift_js_return_string"] = function(ptr, len) {
+                const bytes = new Uint8Array(memory.buffer, ptr, len);
+                tmpRetString = textDecoder.decode(bytes);
+            }
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
+                const source = swift.memory.getObject(sourceId);
+                const bytes = new Uint8Array(memory.buffer, bytesPtr);
+                bytes.set(source);
+            }
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
+                const bytes = new Uint8Array(memory.buffer, ptr, len);
+                return swift.memory.retain(textDecoder.decode(bytes));
+            }
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
+                const target = new Uint8Array(memory.buffer, ptr, len);
+                target.set(tmpRetBytes);
+                tmpRetBytes = undefined;
+            }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
+            const TestModule = importObject["TestModule"] = {};
+            TestModule["bjs_returnAnimatable"] = function bjs_returnAnimatable() {
+                try {
+                    let ret = options.imports.returnAnimatable();
+                    return swift.memory.retain(ret);
+                } catch (error) {
+                    setException(error);
+                    return 0
+                }
+            }
+            TestModule["bjs_Animatable_animate"] = function bjs_Animatable_animate(self, keyframes, options) {
+                try {
+                    let ret = swift.memory.getObject(self).animate(swift.memory.getObject(keyframes), swift.memory.getObject(options));
+                    return swift.memory.retain(ret);
+                } catch (error) {
+                    setException(error);
+                    return 0
+                }
+            }
+            TestModule["bjs_Animatable_getAnimations"] = function bjs_Animatable_getAnimations(self, options) {
+                try {
+                    let ret = swift.memory.getObject(self).getAnimations(swift.memory.getObject(options));
+                    return swift.memory.retain(ret);
+                } catch (error) {
+                    setException(error);
+                    return 0
+                }
+            }
+        },
+        setInstance: (i) => {
+            instance = i;
+            memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
+        },
+        /** @param {WebAssembly.Instance} instance */
+        createExports: (instance) => {
+            const js = swift.memory.heap;
+        
+            return {
+
+            };
+        },
+    }
+}