BridgeJSBuildPlugin.swift

#if canImport(PackagePlugin)
import PackagePlugin
import Foundation

/// Build plugin for runtime code generation with BridgeJS.
/// This plugin automatically generates bridge code between Swift and JavaScript
/// during each build process.
@main
struct BridgeJSBuildPlugin: BuildToolPlugin {
    func createBuildCommands(context: PluginContext, target: Target) throws -> [Command] {
        guard let swiftSourceModuleTarget = target as? SwiftSourceModuleTarget else {
            return []
        }
        return [try createGenerateCommand(context: context, target: swiftSourceModuleTarget)]
    }

    private func pathToConfigFile(target: SwiftSourceModuleTarget) -> URL {
        return target.directoryURL.appending(path: "bridge-js.config.json")
    }

    private func createGenerateCommand(context: PluginContext, target: SwiftSourceModuleTarget) throws -> Command {
        let outputSwiftPath = context.pluginWorkDirectoryURL.appending(path: "BridgeJS.swift")

        let inputSwiftFiles = target.sourceFiles.filter {
            !$0.url.path.hasPrefix(context.pluginWorkDirectoryURL.path + "/")
        }
        .map(\.url)

        let configFile = pathToConfigFile(target: target)
        var inputFiles: [URL] = inputSwiftFiles
        if FileManager.default.fileExists(atPath: configFile.path) {
            inputFiles.append(configFile)
        }

        // Include Swift files generated by other plugins applied to this
        // target (available in tools-version 6.0+). This lets BridgeJS
        // process @JS annotations in files produced by earlier plugins
        // without requiring any extra configuration.
        let pluginGeneratedSwiftFiles = target.pluginGeneratedSources.filter {
            $0.pathExtension == "swift"
        }
        inputFiles.append(contentsOf: pluginGeneratedSwiftFiles)

        let inputTSFile = target.directoryURL.appending(path: "bridge-js.d.ts")
        let tsconfigPath = context.package.directoryURL.appending(path: "tsconfig.json")

        var arguments: [String] = [
            "generate",
            "--module-name",
            target.name,
            "--target-dir",
            target.directoryURL.path,
            "--output-dir",
            context.pluginWorkDirectoryURL.path,
            "--always-write", "true",
        ]

        if FileManager.default.fileExists(atPath: inputTSFile.path) {
            inputFiles.append(contentsOf: [inputTSFile, tsconfigPath])
            arguments.append(contentsOf: [
                "--project",
                tsconfigPath.path,
            ])
        }

        for skeleton in dependencySkeletons(context: context, target: target) {
            arguments.append(contentsOf: [
                "--dependency-skeleton",
                "\(skeleton.moduleName)=\(skeleton.skeletonURL.path)",
            ])
            // We have to use the Swift file, not the skeleton, as the input file,
            // since we can’t make the skeleton file an output file without it being
            // treated as a resource by the build system (and thus included in the
            // resource bundle). We need to use something as the inputFile to maintain
            // correct ordering.
            inputFiles.append(skeleton.bridgeJSSwiftURL)
        }

        let allSwiftFiles = inputSwiftFiles + pluginGeneratedSwiftFiles
        arguments.append(contentsOf: allSwiftFiles.map(\.path))

        return .buildCommand(
            displayName: "Generate BridgeJS code",
            executable: try context.tool(named: "BridgeJSTool").url,
            arguments: arguments,
            inputFiles: inputFiles,
            outputFiles: [outputSwiftPath]
        )
    }

    private struct DependencySkeleton {
        let moduleName: String
        let skeletonURL: URL
        let bridgeJSSwiftURL: URL
    }

    /// We only read skeletons from dependencies with a `bridge-js.config.json` file.
    /// For the build system to correctly order the plugins, we need to set the skeleton
    /// files as input. However, I don’t think we have enough information here to determine
    /// whether the plugin which generates this is applied to the dependency, so we use
    /// the presence of `bridge-js.config.json` instead.
    private func dependencySkeletons(
        context: PluginContext,
        target: SwiftSourceModuleTarget
    ) -> [DependencySkeleton] {
        let localTargets: [SwiftSourceModuleTarget] = target.recursiveTargetDependencies
            .compactMap { dependency in
                guard
                    let swiftTarget = dependency as? SwiftSourceModuleTarget,
                    context.package.targets.contains(where: { $0.id == swiftTarget.id }),
                    FileManager.default.fileExists(atPath: pathToConfigFile(target: swiftTarget).path)
                else {
                    return nil
                }
                return swiftTarget
            }

        var skeletons: [DependencySkeleton] = []
        var seenTargetNames = Set<String>()
        for swiftTarget in localTargets where seenTargetNames.insert(swiftTarget.name).inserted {
            let skeletonURL = BridgeJSPluginPaths.skeletonURL(
                targetName: swiftTarget.name,
                packageID: context.package.id,
                buildPluginWorkDirectoryURL: context.pluginWorkDirectoryURL
            )
            let bridgeJSSwiftURL = BridgeJSPluginPaths.bridgeJSSwiftURL(
                targetName: swiftTarget.name,
                packageID: context.package.id,
                buildPluginWorkDirectoryURL: context.pluginWorkDirectoryURL
            )
            skeletons.append(
                DependencySkeleton(
                    moduleName: swiftTarget.name,
                    skeletonURL: skeletonURL,
                    bridgeJSSwiftURL: bridgeJSSwiftURL
                )
            )
        }
        return skeletons
    }
}
#endif