@decohere/forge 0.0.1-dev.10

package/es6/src/services/swc-transpiler.js

@@ -0,0 +1,213 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import fs from "node:fs";
+import path from "node:path";
+import { cache, invalidateCache } from "@decohere/nexus/caching";
+import { Trace } from "@decohere/nexus/diagnostics";
+import { mixwith } from "@decohere/nexus/extensibility";
+import { io } from "@decohere/nexus/io";
+import { transform, transformSync } from "@swc/core";
+import { BuildTargets } from "../types/build-target.type.js";
+import "../extensions/project.extensions.js";
+import { SwcConfigFactory } from "../factories/swc-config.factory.js";
+import { CachesOutputs } from "../mixins/caches-outputs.mixin.js";
+import { IncrementalTransform } from "../mixins/incremental-transform.mixin.js";
+import { TransformResponse } from "../types/transform-response.model.js";
+export class SwcTranspiler extends mixwith(CachesOutputs, IncrementalTransform) {
+    buildTargets = [
+        BuildTargets.es6,
+        BuildTargets.commonjs
+    ];
+    #swcConfigFactory = new SwcConfigFactory();
+    async transformProject(projectArrayLike, fileFilter, onOutput) {
+        const projects = Array.isArray(projectArrayLike) ? projectArrayLike : [
+            projectArrayLike
+        ];
+        const responses = await Promise.all(projects.map(async (project)=>{
+            const { targets, aliasPaths } = project.getForgeConfiguration();
+            const transpileTargets = targets.filter((bt)=>bt !== BuildTargets.types);
+            if (transpileTargets.length === 0) {
+                return [];
+            }
+            const sourceFiles = await (fileFilter?.(project) ?? project.getAllFiles());
+            const tsConfig = await project.getTsConfig();
+            const userConfig = await project.getSwcConfig();
+            const responses = await Promise.all(transpileTargets.map((target)=>{
+                return this.transformTarget(sourceFiles, target, {
+                    tsConfig,
+                    userConfig,
+                    aliasPaths
+                }, project, onOutput);
+            }));
+            return responses.flat();
+        }));
+        const flat = responses.flat();
+        this.cacheOutputs(flat);
+        return flat;
+    }
+    async transformFile(fileArrayLike, buildTarget, options = {}) {
+        const files = Array.isArray(fileArrayLike) ? fileArrayLike : [
+            fileArrayLike
+        ];
+        const responses = this.transformTarget(files, buildTarget, options);
+        return responses;
+    }
+    /**
+	 * Synchronous, single-file variant of `transformFile`.
+	 * Reads the file with `fs.readFileSync` and transpiles via `swc.transformSync`.
+	 * Intended for callers that cannot await (e.g. Node.js `registerHooks` load hook).
+	 */ transformFileSync(file, buildTarget, options = {}) {
+        const baseConfig = this.#swcConfigFactory.createBaseConfig(buildTarget, options);
+        const swcOptions = this.#swcConfigFactory.createFileConfig(file, baseConfig);
+        let content;
+        try {
+            content = fs.readFileSync(file.fullPath, "utf8");
+        } catch (error) {
+            return TransformResponse.Error({
+                file,
+                messages: [
+                    String(error)
+                ],
+                config: swcOptions
+            });
+        }
+        if (content === "") {
+            return TransformResponse.Skipped({
+                file,
+                messages: "File is empty",
+                config: swcOptions
+            });
+        }
+        try {
+            const transformed = transformSync(content, swcOptions);
+            if (transformed == null) {
+                throw new Error("swc.transformSync returned no result");
+            }
+            const filePath = file.relativePath;
+            const extName = path.extname(filePath);
+            const fileName = filePath.replace(new RegExp(`${extName}$`), ".js");
+            return TransformResponse.Success({
+                file,
+                code: transformed.code,
+                target: buildTarget,
+                fileName,
+                config: swcOptions
+            });
+        } catch (error) {
+            return TransformResponse.Error({
+                file,
+                messages: [
+                    String(error)
+                ],
+                config: swcOptions
+            });
+        }
+    }
+    async transformTarget(files, buildTarget, options, project, onOutput) {
+        const baseConfig = this.#swcConfigFactory.createBaseConfig(buildTarget, options ?? {});
+        return await Promise.all(files.map((file)=>{
+            const swcOptions = this.#swcConfigFactory.createFileConfig(file, baseConfig);
+            return this.runTransform(file, buildTarget, swcOptions, project, onOutput);
+        }));
+    }
+    async runTransform(file, target, swcOptions, project, onOutput) {
+        const content = await this.getFileContent(file);
+        if (content === "") {
+            const skipped = TransformResponse.Skipped({
+                file,
+                messages: "File is empty",
+                config: swcOptions,
+                project
+            });
+            onOutput?.(skipped);
+            return skipped;
+        }
+        try {
+            const filePath = file.relativePath;
+            const extName = path.extname(filePath);
+            const fileName = filePath.replace(new RegExp(`${extName}$`), ".js");
+            const outBaseDir = project?.getOutDir(target);
+            const outputPath = outBaseDir ? path.join(outBaseDir, fileName) : undefined;
+            const outputDir = outputPath ? path.dirname(outputPath) : undefined;
+            const transformed = await transform(content, swcOptions);
+            if (transformed == null) {
+                throw new Error("swc.transform returned no result");
+            }
+            const success = TransformResponse.Success({
+                file,
+                code: transformed.code,
+                target,
+                fileName,
+                outputDir,
+                outputPath,
+                config: swcOptions,
+                project
+            });
+            onOutput?.(success);
+            return success;
+        } catch (error) {
+            const failure = TransformResponse.Error({
+                file,
+                messages: [
+                    String(error)
+                ],
+                config: swcOptions,
+                project
+            });
+            onOutput?.(failure);
+            return failure;
+        }
+    }
+    async onIncrementalFileEvent(evt) {
+        const { file, project } = evt;
+        if (evt.eventName === io.WatchEvents.unlink) {
+            this.deleteCachedOutputs(file.fullPath);
+            return [];
+        }
+        if (!project.isSourceFile(file)) {
+            return [];
+        }
+        this.invalidateContentCache(file);
+        return this.transformProject(project, ()=>Promise.resolve([
+                file
+            ]));
+    }
+    invalidateContentCache(_file) {}
+    getFileContent(file) {
+        return file.getContent();
+    }
+}
+_ts_decorate([
+    invalidateCache(SwcTranspiler.prototype.getFileContent, {
+        name: "FILE_CONTENT",
+        keyFn: (...args)=>args[0].fullPath
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof FileEx === "undefined" ? Object : FileEx
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], SwcTranspiler.prototype, "invalidateContentCache", null);
+_ts_decorate([
+    cache({
+        name: "FILE_CONTENT",
+        keyFn: (...args)=>args[0].fullPath
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof FileEx === "undefined" ? Object : FileEx
+    ]),
+    _ts_metadata("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], SwcTranspiler.prototype, "getFileContent", null);
+SwcTranspiler = _ts_decorate([
+    Trace
+], SwcTranspiler);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/services/swc-transpiler.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport path from \"node:path\";\nimport type { Project } from \"@decohere/mesh\";\nimport { cache, invalidateCache } from \"@decohere/nexus/caching\";\nimport { Trace } from \"@decohere/nexus/diagnostics\";\nimport { mixwith } from \"@decohere/nexus/extensibility\";\nimport type { FileEx } from \"@decohere/nexus/io\";\nimport { io } from \"@decohere/nexus/io\";\nimport { type Options, transform, transformSync } from \"@swc/core\";\nimport {\n\ttype BuildTarget,\n\tBuildTargets,\n\ttype TranspileTarget,\n} from \"../types/build-target.type.js\";\nimport \"../extensions/project.extensions.js\";\nimport type { ProjectFileEvent, Tsconfig } from \"@decohere/mesh\";\nimport { SwcConfigFactory } from \"../factories/swc-config.factory.js\";\nimport { CachesOutputs } from \"../mixins/caches-outputs.mixin.js\";\nimport { IncrementalTransform } from \"../mixins/incremental-transform.mixin.js\";\nimport type { SwcConfig } from \"../types/swc-config.type.js\";\nimport { TransformResponse } from \"../types/transform-response.model.js\";\nimport type { Transformer } from \"../types/transformer.type.js\";\n\nexport type TranspileOptions = {\n\taliasPaths?: boolean;\n\ttsConfig?: Tsconfig;\n\tuserConfig?: SwcConfig;\n};\n\n@Trace\nexport class SwcTranspiler\n\textends mixwith(CachesOutputs, IncrementalTransform)\n\timplements Transformer\n{\n\tpublic buildTargets: BuildTarget[] = [BuildTargets.es6, BuildTargets.commonjs];\n\t#swcConfigFactory = new SwcConfigFactory();\n\n\tpublic async transformProject(\n\t\tprojectArrayLike: Project | Project[],\n\t\tfileFilter?: (project: Project) => Promise<FileEx[]>,\n\t\tonOutput?: (response: TransformResponse) => void,\n\t): Promise<TransformResponse[]> {\n\t\tconst projects = Array.isArray(projectArrayLike) ? projectArrayLike : [projectArrayLike];\n\t\tconst responses = await Promise.all(\n\t\t\tprojects.map(async (project) => {\n\t\t\t\tconst { targets, aliasPaths } = project.getForgeConfiguration();\n\t\t\t\tconst transpileTargets = targets.filter((bt) => bt !== BuildTargets.types);\n\t\t\t\tif (transpileTargets.length === 0) {\n\t\t\t\t\treturn [];\n\t\t\t\t}\n\n\t\t\t\tconst sourceFiles = await (fileFilter?.(project) ?? project.getAllFiles());\n\t\t\t\tconst tsConfig = await project.getTsConfig();\n\t\t\t\tconst userConfig = await project.getSwcConfig();\n\t\t\t\tconst responses = await Promise.all(\n\t\t\t\t\ttranspileTargets.map((target) => {\n\t\t\t\t\t\treturn this.transformTarget(\n\t\t\t\t\t\t\tsourceFiles,\n\t\t\t\t\t\t\ttarget,\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\ttsConfig,\n\t\t\t\t\t\t\t\tuserConfig,\n\t\t\t\t\t\t\t\taliasPaths,\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tproject,\n\t\t\t\t\t\t\tonOutput,\n\t\t\t\t\t\t);\n\t\t\t\t\t}),\n\t\t\t\t);\n\t\t\t\treturn responses.flat();\n\t\t\t}),\n\t\t);\n\n\t\tconst flat = responses.flat();\n\t\tthis.cacheOutputs(flat);\n\t\treturn flat;\n\t}\n\n\tpublic async transformFile(\n\t\tfileArrayLike: FileEx[] | FileEx,\n\t\tbuildTarget: TranspileTarget,\n\t\toptions: TranspileOptions = {},\n\t) {\n\t\tconst files = Array.isArray(fileArrayLike) ? fileArrayLike : [fileArrayLike];\n\t\tconst responses = this.transformTarget(files, buildTarget, options);\n\t\treturn responses;\n\t}\n\n\t/**\n\t * Synchronous, single-file variant of `transformFile`.\n\t * Reads the file with `fs.readFileSync` and transpiles via `swc.transformSync`.\n\t * Intended for callers that cannot await (e.g. Node.js `registerHooks` load hook).\n\t */\n\tpublic transformFileSync(\n\t\tfile: FileEx,\n\t\tbuildTarget: TranspileTarget,\n\t\toptions: TranspileOptions = {},\n\t): TransformResponse {\n\t\tconst baseConfig = this.#swcConfigFactory.createBaseConfig(buildTarget, options);\n\t\tconst swcOptions = this.#swcConfigFactory.createFileConfig(file, baseConfig);\n\n\t\tlet content: string;\n\t\ttry {\n\t\t\tcontent = fs.readFileSync(file.fullPath, \"utf8\");\n\t\t} catch (error) {\n\t\t\treturn TransformResponse.Error({\n\t\t\t\tfile,\n\t\t\t\tmessages: [String(error)],\n\t\t\t\tconfig: swcOptions,\n\t\t\t});\n\t\t}\n\n\t\tif (content === \"\") {\n\t\t\treturn TransformResponse.Skipped({\n\t\t\t\tfile,\n\t\t\t\tmessages: \"File is empty\",\n\t\t\t\tconfig: swcOptions,\n\t\t\t});\n\t\t}\n\n\t\ttry {\n\t\t\tconst transformed = transformSync(content, swcOptions);\n\t\t\tif (transformed == null) {\n\t\t\t\tthrow new Error(\"swc.transformSync returned no result\");\n\t\t\t}\n\t\t\tconst filePath = file.relativePath;\n\t\t\tconst extName = path.extname(filePath);\n\t\t\tconst fileName = filePath.replace(new RegExp(`${extName}$`), \".js\");\n\t\t\treturn TransformResponse.Success({\n\t\t\t\tfile,\n\t\t\t\tcode: transformed.code,\n\t\t\t\ttarget: buildTarget,\n\t\t\t\tfileName,\n\t\t\t\tconfig: swcOptions,\n\t\t\t});\n\t\t} catch (error) {\n\t\t\treturn TransformResponse.Error({\n\t\t\t\tfile,\n\t\t\t\tmessages: [String(error)],\n\t\t\t\tconfig: swcOptions,\n\t\t\t});\n\t\t}\n\t}\n\n\tprivate async transformTarget(\n\t\tfiles: FileEx[],\n\t\tbuildTarget: TranspileTarget,\n\t\toptions?: TranspileOptions,\n\t\tproject?: Project,\n\t\tonOutput?: (response: TransformResponse) => void,\n\t) {\n\t\tconst baseConfig = this.#swcConfigFactory.createBaseConfig(buildTarget, options ?? {});\n\t\treturn await Promise.all(\n\t\t\tfiles.map((file) => {\n\t\t\t\tconst swcOptions = this.#swcConfigFactory.createFileConfig(file, baseConfig);\n\t\t\t\treturn this.runTransform(file, buildTarget, swcOptions, project, onOutput);\n\t\t\t}),\n\t\t);\n\t}\n\n\tprivate async runTransform(\n\t\tfile: FileEx,\n\t\ttarget: BuildTarget,\n\t\tswcOptions: Options,\n\t\tproject?: Project,\n\t\tonOutput?: (response: TransformResponse) => void,\n\t): Promise<TransformResponse> {\n\t\tconst content = await this.getFileContent(file);\n\t\tif (content === \"\") {\n\t\t\tconst skipped = TransformResponse.Skipped({\n\t\t\t\tfile,\n\t\t\t\tmessages: \"File is empty\",\n\t\t\t\tconfig: swcOptions,\n\t\t\t\tproject,\n\t\t\t});\n\t\t\tonOutput?.(skipped);\n\t\t\treturn skipped;\n\t\t}\n\n\t\ttry {\n\t\t\tconst filePath = file.relativePath;\n\t\t\tconst extName = path.extname(filePath);\n\t\t\tconst fileName = filePath.replace(new RegExp(`${extName}$`), \".js\");\n\t\t\tconst outBaseDir = project?.getOutDir(target);\n\t\t\tconst outputPath = outBaseDir ? path.join(outBaseDir, fileName) : undefined;\n\t\t\tconst outputDir = outputPath ? path.dirname(outputPath) : undefined;\n\t\t\tconst transformed = await transform(content, swcOptions);\n\t\t\tif (transformed == null) {\n\t\t\t\tthrow new Error(\"swc.transform returned no result\");\n\t\t\t}\n\n\t\t\tconst success = TransformResponse.Success({\n\t\t\t\tfile,\n\t\t\t\tcode: transformed.code,\n\t\t\t\ttarget,\n\t\t\t\tfileName,\n\t\t\t\toutputDir,\n\t\t\t\toutputPath,\n\t\t\t\tconfig: swcOptions,\n\t\t\t\tproject,\n\t\t\t});\n\t\t\tonOutput?.(success);\n\t\t\treturn success;\n\t\t} catch (error) {\n\t\t\tconst failure = TransformResponse.Error({\n\t\t\t\tfile,\n\t\t\t\tmessages: [String(error)],\n\t\t\t\tconfig: swcOptions,\n\t\t\t\tproject,\n\t\t\t});\n\t\t\tonOutput?.(failure);\n\t\t\treturn failure;\n\t\t}\n\t}\n\n\tprotected async onIncrementalFileEvent(evt: ProjectFileEvent): Promise<TransformResponse[]> {\n\t\tconst { file, project } = evt;\n\t\tif (evt.eventName === io.WatchEvents.unlink) {\n\t\t\tthis.deleteCachedOutputs(file.fullPath);\n\t\t\treturn [];\n\t\t}\n\t\tif (!project.isSourceFile(file)) {\n\t\t\treturn [];\n\t\t}\n\t\tthis.invalidateContentCache(file);\n\t\treturn this.transformProject(project, () => Promise.resolve([file]));\n\t}\n\n\t@invalidateCache(SwcTranspiler.prototype.getFileContent, {\n\t\tname: \"FILE_CONTENT\",\n\t\tkeyFn: (...args) => (args[0] as FileEx).fullPath,\n\t})\n\tpublic invalidateContentCache(_file: FileEx): void {}\n\n\t@cache({ name: \"FILE_CONTENT\", keyFn: (...args) => (args[0] as FileEx).fullPath })\n\tprivate getFileContent(file: FileEx): Promise<string> {\n\t\treturn file.getContent();\n\t}\n}\n"],"names":["fs","path","cache","invalidateCache","Trace","mixwith","io","transform","transformSync","BuildTargets","SwcConfigFactory","CachesOutputs","IncrementalTransform","TransformResponse","SwcTranspiler","buildTargets","es6","commonjs","transformProject","projectArrayLike","fileFilter","onOutput","projects","Array","isArray","responses","Promise","all","map","project","targets","aliasPaths","getForgeConfiguration","transpileTargets","filter","bt","types","length","sourceFiles","getAllFiles","tsConfig","getTsConfig","userConfig","getSwcConfig","target","transformTarget","flat","cacheOutputs","transformFile","fileArrayLike","buildTarget","options","files","transformFileSync","file","baseConfig","createBaseConfig","swcOptions","createFileConfig","content","readFileSync","fullPath","error","Error","messages","String","config","Skipped","transformed","filePath","relativePath","extName","extname","fileName","replace","RegExp","Success","code","runTransform","getFileContent","skipped","outBaseDir","getOutDir","outputPath","join","undefined","outputDir","dirname","success","failure","onIncrementalFileEvent","evt","eventName","WatchEvents","unlink","deleteCachedOutputs","isSourceFile","invalidateContentCache","resolve","_file","getContent","prototype","name","keyFn","args"],"mappings":"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"}

package/es6/src/services/ts-program-host.js

@@ -0,0 +1,120 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import fs from "node:fs";
+import { cache } from "@decohere/nexus/caching";
+import { Trace } from "@decohere/nexus/diagnostics";
+import { createCompilerHost, createProgram } from "typescript";
+import { DEFAULT_TYPE_EMITTER_OPTIONS, REQUIRED_TYPE_EMITTER_OPTIONS } from "./type-emitter.js";
+export class TsProgramHost {
+    #invalidated = new Set();
+    invalidateSourceFile(fileName) {
+        this.#invalidated.add(fileName);
+    }
+    hasInvalidated() {
+        return this.#invalidated.size > 0;
+    }
+    /** Returns a stable string key for a set of compiler options that affect host behaviour. */ hostKey(opts) {
+        return JSON.stringify({
+            target: opts.target,
+            lib: opts.lib,
+            typeRoots: opts.typeRoots,
+            types: opts.types,
+            moduleResolution: opts.moduleResolution,
+            baseUrl: opts.baseUrl,
+            paths: opts.paths,
+            module: opts.module,
+            rootDir: opts.rootDir,
+            rootDirs: opts.rootDirs
+        });
+    }
+    createHost(compilerOptions) {
+        const host = createCompilerHost(compilerOptions);
+        host.fileExists = (fileName)=>this.fileExistsOnDisk(fileName);
+        host.readFile = (fileName)=>this.readFileFromDisk(fileName);
+        host.directoryExists = (directoryName)=>this.directoryExists(directoryName);
+        host.getDirectories = (directoryName)=>this.getDirectories(directoryName);
+        return host;
+    }
+    createProgram(files, compilerOptions, host, oldProgram) {
+        const filePaths = files.map((f)=>f.fullPath);
+        this.#invalidated.clear();
+        return createProgram(filePaths, {
+            ...DEFAULT_TYPE_EMITTER_OPTIONS,
+            ...compilerOptions,
+            ...REQUIRED_TYPE_EMITTER_OPTIONS
+        }, host, oldProgram);
+    }
+    readFileFromDisk(fileName) {
+        try {
+            return fs.readFileSync(fileName, "utf8");
+        } catch  {
+            return undefined;
+        }
+    }
+    fileExistsOnDisk(fileName) {
+        return fs.existsSync(fileName);
+    }
+    directoryExists(directoryName) {
+        try {
+            return fs.statSync(directoryName).isDirectory();
+        } catch  {
+            return false;
+        }
+    }
+    getDirectories(directoryName) {
+        try {
+            return fs.readdirSync(directoryName, {
+                withFileTypes: true
+            }).filter((entry)=>entry.isDirectory()).map((entry)=>entry.name);
+        } catch  {
+            return [];
+        }
+    }
+}
+_ts_decorate([
+    cache({
+        name: "FILE_CONTENT",
+        keyFn: (...args)=>args[0]
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Object)
+], TsProgramHost.prototype, "readFileFromDisk", null);
+_ts_decorate([
+    cache(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Boolean)
+], TsProgramHost.prototype, "fileExistsOnDisk", null);
+_ts_decorate([
+    cache(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Boolean)
+], TsProgramHost.prototype, "directoryExists", null);
+_ts_decorate([
+    cache(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Array)
+], TsProgramHost.prototype, "getDirectories", null);
+TsProgramHost = _ts_decorate([
+    Trace
+], TsProgramHost);
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/services/type-emission-program.js

@@ -0,0 +1,145 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import path from "node:path";
+import { Trace } from "@decohere/nexus/diagnostics";
+import { TransformResponse } from "../types/transform-response.model.js";
+export class TypeEmissionProgram {
+    #program;
+    #group;
+    #targetsByDtsPath;
+    #targetsByEmittedPath;
+    #host;
+    #compilerHost;
+    #allFiles;
+    #compilerOptions;
+    constructor(group, hostFactory){
+        this.#group = group;
+        const targets = this.buildTargetMaps(group);
+        this.#targetsByDtsPath = targets.byDtsPath;
+        this.#targetsByEmittedPath = targets.byEmittedPath;
+        this.#host = hostFactory;
+        this.#compilerOptions = group[0].tsconfig.compilerOptions;
+        this.#allFiles = group.flatMap(({ files })=>files);
+        this.#compilerHost = hostFactory.createHost(this.#compilerOptions);
+        this.#program = hostFactory.createProgram(this.#allFiles, this.#compilerOptions, this.#compilerHost);
+    }
+    toEmissionTarget(groupProject, file, outBaseDir) {
+        const extName = path.extname(file.relativePath);
+        const dtsRelative = file.relativePath.replace(new RegExp(`${extName}$`), ".d.ts");
+        const outputPath = path.join(outBaseDir, dtsRelative);
+        return {
+            file,
+            tsconfig: groupProject.tsconfig,
+            project: groupProject.project,
+            outputPath,
+            outputDir: path.dirname(outputPath),
+            dtsRelative
+        };
+    }
+    emittedKey(file) {
+        return file.fullPath.replace(/\.[^.]+$/, ".d.ts");
+    }
+    buildTargetMaps(group) {
+        const byDtsPath = new Map();
+        const byEmittedPath = new Map();
+        for (const groupProject of group){
+            const outBaseDir = groupProject.project.getOutDir("types");
+            for (const file of groupProject.files){
+                const target = this.toEmissionTarget(groupProject, file, outBaseDir);
+                byDtsPath.set(target.dtsRelative, target);
+                byEmittedPath.set(this.emittedKey(file), target);
+            }
+        }
+        return {
+            byDtsPath,
+            byEmittedPath
+        };
+    }
+    addFile(file, project) {
+        const groupProject = this.#group.find((g)=>g.project === project);
+        if (groupProject == null) return;
+        groupProject.files.push(file);
+        this.#allFiles.push(file);
+        const outBaseDir = groupProject.project.getOutDir("types");
+        const target = this.toEmissionTarget(groupProject, file, outBaseDir);
+        this.#targetsByDtsPath.set(target.dtsRelative, target);
+        this.#targetsByEmittedPath.set(this.emittedKey(file), target);
+        this.#host.invalidateSourceFile(file.fullPath);
+    }
+    async emit(fileFilter, onOutput) {
+        if (this.#host.hasInvalidated()) {
+            this.#program = this.#host.createProgram(this.#allFiles, this.#compilerOptions, this.#compilerHost, this.#program);
+        }
+        if (fileFilter == null) {
+            return this.emitAll(onOutput);
+        }
+        return this.emitFiltered(fileFilter, onOutput);
+    }
+    emitAll(onOutput) {
+        const responses = [];
+        this.#program.emit(undefined, (emittedPath, content)=>{
+            if (!emittedPath.endsWith(".d.ts")) {
+                return;
+            }
+            const response = this.toTransformResponse(emittedPath, content);
+            responses.push(response);
+            onOutput?.(response);
+        });
+        return responses;
+    }
+    async emitFiltered(fileFilter, onOutput) {
+        const files = await Promise.all(this.#group.map(({ project })=>fileFilter(project)));
+        const sourceFiles = files.flat().map((file)=>this.#program.getSourceFile(file.fullPath)).filter((sf)=>sf != null);
+        const responses = [];
+        for (const sourceFile of sourceFiles){
+            this.#program.emit(sourceFile, (emittedPath, content)=>{
+                if (!emittedPath.endsWith(".d.ts")) {
+                    return;
+                }
+                const response = this.toTransformResponse(emittedPath, content);
+                responses.push(response);
+                onOutput?.(response);
+            });
+        }
+        return responses;
+    }
+    toTransformResponse(emittedPath, content) {
+        const target = this.#targetsByEmittedPath.get(emittedPath);
+        if (target == null) {
+            throw new Error(`No matching emission target for: ${emittedPath}`);
+        }
+        return this.toTransformResponseFromTarget(target, content);
+    }
+    toTransformResponseFromTarget(target, content) {
+        const { file, tsconfig, project, outputPath, outputDir, dtsRelative } = target;
+        return TransformResponse.from({
+            file,
+            config: tsconfig,
+            outcome: "success",
+            fileName: dtsRelative,
+            code: content,
+            target: "types",
+            messages: [],
+            project,
+            outputDir,
+            outputPath
+        });
+    }
+}
+TypeEmissionProgram = _ts_decorate([
+    Trace,
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Array,
+        typeof TsProgramHost === "undefined" ? Object : TsProgramHost
+    ])
+], TypeEmissionProgram);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/services/type-emission-program.ts"],"sourcesContent":["import path from \"node:path\";\nimport type { Project, Tsconfig } from \"@decohere/mesh\";\nimport { Trace } from \"@decohere/nexus/diagnostics\";\nimport type { FileEx } from \"@decohere/nexus/io\";\nimport type ts from \"typescript\";\nimport type { TsProgramHost } from \"../services/ts-program-host.js\";\nimport { TransformResponse } from \"../types/transform-response.model.js\";\n\nexport type TypeProgramProject = {\n\tproject: Project;\n\tfiles: FileEx[];\n\ttsconfig: Tsconfig;\n};\n\ntype EmissionTarget = {\n\tfile: FileEx;\n\ttsconfig: Tsconfig;\n\tproject: Project;\n\toutputPath: string;\n\toutputDir: string;\n\tdtsRelative: string;\n};\n\n@Trace\nexport class TypeEmissionProgram {\n\t#program: ts.Program;\n\t#group: TypeProgramProject[];\n\t#targetsByDtsPath: Map<string, EmissionTarget>;\n\t#targetsByEmittedPath: Map<string, EmissionTarget>;\n\t#host: TsProgramHost;\n\t#compilerHost: ts.CompilerHost;\n\t#allFiles: FileEx[];\n\t#compilerOptions: ts.CompilerOptions;\n\n\tpublic constructor(group: TypeProgramProject[], hostFactory: TsProgramHost) {\n\t\tthis.#group = group;\n\t\tconst targets = this.buildTargetMaps(group);\n\t\tthis.#targetsByDtsPath = targets.byDtsPath;\n\t\tthis.#targetsByEmittedPath = targets.byEmittedPath;\n\t\tthis.#host = hostFactory;\n\t\tthis.#compilerOptions = group[0].tsconfig.compilerOptions;\n\t\tthis.#allFiles = group.flatMap(({ files }) => files);\n\t\tthis.#compilerHost = hostFactory.createHost(this.#compilerOptions);\n\t\tthis.#program = hostFactory.createProgram(\n\t\t\tthis.#allFiles,\n\t\t\tthis.#compilerOptions,\n\t\t\tthis.#compilerHost,\n\t\t);\n\t}\n\n\tprivate toEmissionTarget(\n\t\tgroupProject: TypeProgramProject,\n\t\tfile: FileEx,\n\t\toutBaseDir: string,\n\t): EmissionTarget {\n\t\tconst extName = path.extname(file.relativePath);\n\t\tconst dtsRelative = file.relativePath.replace(new RegExp(`${extName}$`), \".d.ts\");\n\t\tconst outputPath = path.join(outBaseDir, dtsRelative);\n\t\treturn {\n\t\t\tfile,\n\t\t\ttsconfig: groupProject.tsconfig,\n\t\t\tproject: groupProject.project,\n\t\t\toutputPath,\n\t\t\toutputDir: path.dirname(outputPath),\n\t\t\tdtsRelative,\n\t\t};\n\t}\n\n\tprivate emittedKey(file: FileEx): string {\n\t\treturn file.fullPath.replace(/\\.[^.]+$/, \".d.ts\");\n\t}\n\n\tprivate buildTargetMaps(group: TypeProgramProject[]): {\n\t\tbyDtsPath: Map<string, EmissionTarget>;\n\t\tbyEmittedPath: Map<string, EmissionTarget>;\n\t} {\n\t\tconst byDtsPath = new Map<string, EmissionTarget>();\n\t\tconst byEmittedPath = new Map<string, EmissionTarget>();\n\n\t\tfor (const groupProject of group) {\n\t\t\tconst outBaseDir = groupProject.project.getOutDir(\"types\");\n\t\t\tfor (const file of groupProject.files) {\n\t\t\t\tconst target = this.toEmissionTarget(groupProject, file, outBaseDir);\n\t\t\t\tbyDtsPath.set(target.dtsRelative, target);\n\t\t\t\tbyEmittedPath.set(this.emittedKey(file), target);\n\t\t\t}\n\t\t}\n\n\t\treturn { byDtsPath, byEmittedPath };\n\t}\n\n\tpublic addFile(file: FileEx, project: Project): void {\n\t\tconst groupProject = this.#group.find((g) => g.project === project);\n\t\tif (groupProject == null) return;\n\n\t\tgroupProject.files.push(file);\n\t\tthis.#allFiles.push(file);\n\n\t\tconst outBaseDir = groupProject.project.getOutDir(\"types\");\n\t\tconst target = this.toEmissionTarget(groupProject, file, outBaseDir);\n\t\tthis.#targetsByDtsPath.set(target.dtsRelative, target);\n\t\tthis.#targetsByEmittedPath.set(this.emittedKey(file), target);\n\t\tthis.#host.invalidateSourceFile(file.fullPath);\n\t}\n\n\tpublic async emit(\n\t\tfileFilter?: (project: Project) => Promise<FileEx[]>,\n\t\tonOutput?: (response: TransformResponse) => void,\n\t): Promise<TransformResponse[]> {\n\t\tif (this.#host.hasInvalidated()) {\n\t\t\tthis.#program = this.#host.createProgram(\n\t\t\t\tthis.#allFiles,\n\t\t\t\tthis.#compilerOptions,\n\t\t\t\tthis.#compilerHost,\n\t\t\t\tthis.#program,\n\t\t\t);\n\t\t}\n\t\tif (fileFilter == null) {\n\t\t\treturn this.emitAll(onOutput);\n\t\t}\n\t\treturn this.emitFiltered(fileFilter, onOutput);\n\t}\n\n\tprivate emitAll(onOutput?: (response: TransformResponse) => void): TransformResponse[] {\n\t\tconst responses: TransformResponse[] = [];\n\t\tthis.#program.emit(undefined, (emittedPath, content) => {\n\t\t\tif (!emittedPath.endsWith(\".d.ts\")) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst response = this.toTransformResponse(emittedPath, content);\n\t\t\tresponses.push(response);\n\t\t\tonOutput?.(response);\n\t\t});\n\t\treturn responses;\n\t}\n\n\tprivate async emitFiltered(\n\t\tfileFilter: (project: Project) => Promise<FileEx[]>,\n\t\tonOutput?: (response: TransformResponse) => void,\n\t): Promise<TransformResponse[]> {\n\t\tconst files = await Promise.all(this.#group.map(({ project }) => fileFilter(project)));\n\t\tconst sourceFiles = files\n\t\t\t.flat()\n\t\t\t.map((file) => this.#program.getSourceFile(file.fullPath))\n\t\t\t.filter((sf): sf is ts.SourceFile => sf != null);\n\n\t\tconst responses: TransformResponse[] = [];\n\n\t\tfor (const sourceFile of sourceFiles) {\n\t\t\tthis.#program.emit(sourceFile, (emittedPath, content) => {\n\t\t\t\tif (!emittedPath.endsWith(\".d.ts\")) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tconst response = this.toTransformResponse(emittedPath, content);\n\t\t\t\tresponses.push(response);\n\t\t\t\tonOutput?.(response);\n\t\t\t});\n\t\t}\n\n\t\treturn responses;\n\t}\n\n\tprivate toTransformResponse(emittedPath: string, content: string): TransformResponse {\n\t\tconst target = this.#targetsByEmittedPath.get(emittedPath);\n\t\tif (target == null) {\n\t\t\tthrow new Error(`No matching emission target for: ${emittedPath}`);\n\t\t}\n\t\treturn this.toTransformResponseFromTarget(target, content);\n\t}\n\n\tprivate toTransformResponseFromTarget(\n\t\ttarget: EmissionTarget,\n\t\tcontent: string,\n\t): TransformResponse {\n\t\tconst { file, tsconfig, project, outputPath, outputDir, dtsRelative } = target;\n\t\treturn TransformResponse.from({\n\t\t\tfile,\n\t\t\tconfig: tsconfig,\n\t\t\toutcome: \"success\",\n\t\t\tfileName: dtsRelative,\n\t\t\tcode: content,\n\t\t\ttarget: \"types\",\n\t\t\tmessages: [],\n\t\t\tproject,\n\t\t\toutputDir,\n\t\t\toutputPath,\n\t\t});\n\t}\n}\n"],"names":["path","Trace","TransformResponse","TypeEmissionProgram","group","hostFactory","targets","buildTargetMaps","byDtsPath","byEmittedPath","tsconfig","compilerOptions","flatMap","files","createHost","createProgram","toEmissionTarget","groupProject","file","outBaseDir","extName","extname","relativePath","dtsRelative","replace","RegExp","outputPath","join","project","outputDir","dirname","emittedKey","fullPath","Map","getOutDir","target","set","addFile","find","g","push","invalidateSourceFile","emit","fileFilter","onOutput","hasInvalidated","emitAll","emitFiltered","responses","undefined","emittedPath","content","endsWith","response","toTransformResponse","Promise","all","map","sourceFiles","flat","getSourceFile","filter","sf","sourceFile","get","Error","toTransformResponseFromTarget","from","config","outcome","fileName","code","messages"],"mappings":"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"}