kist/js/actions/TypeScriptCompilerAction/TypeScriptCompilerAction.js

Lightweight Package Pipeline Processor with Plugin Architecture

import path from "path";
import ts from "typescript";
import { Action } from "../../core/pipeline/Action.js";
export class TypeScriptCompilerAction extends Action {
    async execute(options) {
        const { tsconfigPath = "tsconfig.json", filePaths, outputDir, compilerOptions = {}, } = options;
        const resolvedTsconfigPath = path.resolve(tsconfigPath);
        this.logInfo(`Compiling TypeScript using configuration: ${resolvedTsconfigPath}`);
        try {
            const parsedConfig = this.loadAndParseTsConfig(resolvedTsconfigPath);
            const mergedCompilerOptions = ts.convertCompilerOptionsFromJson(compilerOptions, path.dirname(resolvedTsconfigPath)).options;
            const finalCompilerOptions = {
                ...parsedConfig.options,
                ...mergedCompilerOptions,
            };
            if (outputDir) {
                mergedCompilerOptions.outDir = outputDir;
            }
            const program = ts.createProgram(filePaths ?? parsedConfig.fileNames, finalCompilerOptions);
            const emitResult = program.emit();
            const allDiagnostics = ts
                .getPreEmitDiagnostics(program)
                .concat(emitResult.diagnostics);
            if (allDiagnostics.length > 0) {
                allDiagnostics.forEach((diagnostic) => {
                    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
                    this.logError(`TypeScript Error: ${message}`);
                });
                throw new Error("TypeScript compilation failed due to errors.");
            }
            this.logInfo("TypeScript compilation completed successfully.");
        }
        catch (error) {
            this.logError("Error during TypeScript compilation:", error);
            const message = error instanceof Error ? error.message : String(error);
            throw new Error(`TypeScript compilation failed: ${message}`);
        }
    }
    loadAndParseTsConfig(tsconfigPath) {
        const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
        if (configFile.error) {
            throw new Error(`Error reading tsconfig.json: ${ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`);
        }
        const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(tsconfigPath));
        if (parsedConfig.errors.length > 0) {
            throw new Error(`Error parsing tsconfig.json: ${parsedConfig.errors
                .map((diag) => ts.flattenDiagnosticMessageText(diag.messageText, "\n"))
                .join("\n")}`);
        }
        return parsedConfig;
    }
    describe() {
        return "Compiles TypeScript files using a given tsconfig.json configuration.";
    }
}
//# sourceMappingURL=TypeScriptCompilerAction.js.map