@decohere/forge 0.0.1-dev.5

package/commonjs/src/services/file-writer.service.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FileWriterService", {
+    enumerable: true,
+    get: function() {
+        return FileWriterService;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
+const _decorators = require("@decohere/crucible/decorators");
+const _diagnostics = require("@decohere/nexus/diagnostics");
+const _io = require("@decohere/nexus/io");
+require("../extensions/project.extensions.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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;
+}
+const DEFAULT_WRITE_CONCURRENCY = 16;
+class FileWriterService {
+    #artifactByPath = new Map();
+    #warmupSignature = "";
+    #warmupPromise;
+    #initialized = false;
+    #pendingWrites = [];
+    #activeWorkers = 0;
+    #drainResolvers = [];
+    #ensuredDirs = new Set();
+    #ensureDirPromises = new Map();
+    #workerError;
+    async initialize() {
+        if (this.#initialized) {
+            return;
+        }
+        this.#initialized = true;
+    }
+    async warmup(projects) {
+        const outputDirs = this.getOutputDirs(projects);
+        const signature = outputDirs.join("|");
+        if (signature === this.#warmupSignature && this.#warmupPromise != null) {
+            return this.#warmupPromise;
+        }
+        this.#warmupSignature = signature;
+        this.#ensuredDirs.clear();
+        this.#ensureDirPromises.clear();
+        this.#workerError = undefined;
+        this.#warmupPromise = this.loadExistingArtifacts(outputDirs);
+        return this.#warmupPromise;
+    }
+    enqueueOutput(response) {
+        if (this.#workerError != null) {
+            return;
+        }
+        if (response.outcome !== "success" || response.outputPath == null) {
+            return;
+        }
+        this.#pendingWrites.push(response);
+        this.startWorkers();
+    }
+    enqueueOutputs(responses) {
+        for (const response of responses){
+            this.enqueueOutput(response);
+        }
+    }
+    async flush() {
+        if (this.#warmupPromise != null) {
+            await this.#warmupPromise;
+        }
+        if (this.#pendingWrites.length === 0 && this.#activeWorkers === 0) {
+            return;
+        }
+        await new Promise((resolve)=>{
+            this.#drainResolvers.push(resolve);
+        });
+        if (this.#workerError != null) {
+            throw this.#workerError;
+        }
+    }
+    getOutputDirs(projects) {
+        const dirs = new Set();
+        for (const project of projects){
+            for (const target of project.getForgeConfiguration().targets){
+                dirs.add(project.getOutDir(target));
+            }
+        }
+        return [
+            ...dirs
+        ].sort();
+    }
+    async loadExistingArtifacts(outputDirs) {
+        this.#artifactByPath.clear();
+        const files = [];
+        for (const dir of outputDirs){
+            files.push(...await this.collectFiles(dir));
+        }
+        await this.withConcurrency(files, this.getWriteConcurrency(), async (filePath)=>{
+            const content = await _promises.default.readFile(filePath, "utf8");
+            this.#artifactByPath.set(filePath, content);
+        });
+    }
+    async collectFiles(rootDir) {
+        try {
+            const entries = await _promises.default.readdir(rootDir, {
+                withFileTypes: true
+            });
+            const files = [];
+            for (const entry of entries){
+                const fullPath = `${rootDir}/${entry.name}`;
+                if (entry.isDirectory()) {
+                    files.push(...await this.collectFiles(fullPath));
+                } else if (entry.isFile()) {
+                    files.push(fullPath);
+                }
+            }
+            return files;
+        } catch  {
+            return [];
+        }
+    }
+    getWriteConcurrency() {
+        const requested = Number(process.env.FORGE_WRITE_CONCURRENCY);
+        if (Number.isFinite(requested) && requested > 0) {
+            return Math.floor(requested);
+        }
+        return DEFAULT_WRITE_CONCURRENCY;
+    }
+    startWorkers() {
+        if (this.#workerError != null) {
+            return;
+        }
+        const maxWorkers = this.getWriteConcurrency();
+        while(this.#activeWorkers < maxWorkers && this.#pendingWrites.length > 0){
+            this.#activeWorkers += 1;
+            void this.runWorker().finally(()=>{
+                this.#activeWorkers -= 1;
+                if (this.#pendingWrites.length > 0) {
+                    this.startWorkers();
+                } else if (this.#activeWorkers === 0) {
+                    this.resolveDrain();
+                }
+            });
+        }
+    }
+    async runWorker() {
+        while(true){
+            const response = this.#pendingWrites.shift();
+            if (response == null) {
+                return;
+            }
+            try {
+                if (this.#warmupPromise != null) {
+                    await this.#warmupPromise;
+                }
+                const outputPath = response.outputPath;
+                if (outputPath == null) {
+                    continue;
+                }
+                const outputDir = response.outputDir;
+                if (outputDir != null) {
+                    await this.ensureDirectory(outputDir);
+                }
+                const existing = this.#artifactByPath.get(outputPath);
+                if (existing === response.code) {
+                    continue;
+                }
+                await _io.io.writeFile(outputPath, response.code);
+                this.#artifactByPath.set(outputPath, response.code);
+            } catch (error) {
+                this.#workerError = error;
+                this.#pendingWrites = [];
+                return;
+            }
+        }
+    }
+    ensureDirectory(dir) {
+        if (this.#ensuredDirs.has(dir)) {
+            return Promise.resolve();
+        }
+        const existing = this.#ensureDirPromises.get(dir);
+        if (existing != null) {
+            return existing;
+        }
+        const mkdirPromise = _promises.default.mkdir(dir, {
+            recursive: true
+        }).then(()=>{
+            this.#ensuredDirs.add(dir);
+            this.#ensureDirPromises.delete(dir);
+        });
+        this.#ensureDirPromises.set(dir, mkdirPromise);
+        return mkdirPromise;
+    }
+    resolveDrain() {
+        if (this.#pendingWrites.length > 0 || this.#activeWorkers > 0) {
+            return;
+        }
+        for (const resolve of this.#drainResolvers){
+            resolve();
+        }
+        this.#drainResolvers = [];
+    }
+    async withConcurrency(items, concurrency, worker) {
+        let cursor = 0;
+        const workerCount = Math.min(concurrency, items.length);
+        const workers = Array.from({
+            length: workerCount
+        }, ()=>(async ()=>{
+                while(true){
+                    const index = cursor;
+                    cursor += 1;
+                    if (index >= items.length) {
+                        return;
+                    }
+                    await worker(items[index]);
+                }
+            })());
+        await Promise.all(workers);
+    }
+}
+FileWriterService = _ts_decorate([
+    _diagnostics.Trace,
+    (0, _decorators.injectable)()
+], FileWriterService);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/projects/forge/src/services/file-writer.service.ts"],"sourcesContent":["import fs from \"node:fs/promises\";\nimport { injectable } from \"@decohere/crucible/decorators\";\nimport type { Project } from \"@decohere/mesh\";\nimport { Trace } from \"@decohere/nexus/diagnostics\";\nimport { io } from \"@decohere/nexus/io\";\nimport \"../extensions/project.extensions.js\";\nimport type { BuildTarget } from \"../types/build-target.type.js\";\nimport type { TransformResponse } from \"../types/transform-response.model.js\";\n\nconst DEFAULT_WRITE_CONCURRENCY = 16;\n\n@Trace\n@injectable()\nexport class FileWriterService {\n\t#artifactByPath = new Map<string, string>();\n\t#warmupSignature = \"\";\n\t#warmupPromise: Promise<void> | undefined;\n\t#initialized = false;\n\t#pendingWrites: TransformResponse[] = [];\n\t#activeWorkers = 0;\n\t#drainResolvers: Array<() => void> = [];\n\t#ensuredDirs = new Set<string>();\n\t#ensureDirPromises = new Map<string, Promise<void>>();\n\t#workerError: unknown;\n\n\tpublic async initialize(): Promise<void> {\n\t\tif (this.#initialized) {\n\t\t\treturn;\n\t\t}\n\t\tthis.#initialized = true;\n\t}\n\n\tpublic async warmup(projects: Project[]): Promise<void> {\n\t\tconst outputDirs = this.getOutputDirs(projects);\n\t\tconst signature = outputDirs.join(\"|\");\n\t\tif (signature === this.#warmupSignature && this.#warmupPromise != null) {\n\t\t\treturn this.#warmupPromise;\n\t\t}\n\n\t\tthis.#warmupSignature = signature;\n\t\tthis.#ensuredDirs.clear();\n\t\tthis.#ensureDirPromises.clear();\n\t\tthis.#workerError = undefined;\n\t\tthis.#warmupPromise = this.loadExistingArtifacts(outputDirs);\n\t\treturn this.#warmupPromise;\n\t}\n\n\tpublic enqueueOutput(response: TransformResponse): void {\n\t\tif (this.#workerError != null) {\n\t\t\treturn;\n\t\t}\n\t\tif (response.outcome !== \"success\" || response.outputPath == null) {\n\t\t\treturn;\n\t\t}\n\t\tthis.#pendingWrites.push(response);\n\t\tthis.startWorkers();\n\t}\n\n\tpublic enqueueOutputs(responses: TransformResponse[]): void {\n\t\tfor (const response of responses) {\n\t\t\tthis.enqueueOutput(response);\n\t\t}\n\t}\n\n\tpublic async flush(): Promise<void> {\n\t\tif (this.#warmupPromise != null) {\n\t\t\tawait this.#warmupPromise;\n\t\t}\n\t\tif (this.#pendingWrites.length === 0 && this.#activeWorkers === 0) {\n\t\t\treturn;\n\t\t}\n\t\tawait new Promise<void>((resolve) => {\n\t\t\tthis.#drainResolvers.push(resolve);\n\t\t});\n\t\tif (this.#workerError != null) {\n\t\t\tthrow this.#workerError;\n\t\t}\n\t}\n\n\tprivate getOutputDirs(projects: Project[]): string[] {\n\t\tconst dirs = new Set<string>();\n\t\tfor (const project of projects) {\n\t\t\tfor (const target of project.getForgeConfiguration().targets) {\n\t\t\t\tdirs.add(project.getOutDir(target as BuildTarget));\n\t\t\t}\n\t\t}\n\t\treturn [...dirs].sort();\n\t}\n\n\tprivate async loadExistingArtifacts(outputDirs: string[]): Promise<void> {\n\t\tthis.#artifactByPath.clear();\n\n\t\tconst files: string[] = [];\n\t\tfor (const dir of outputDirs) {\n\t\t\tfiles.push(...(await this.collectFiles(dir)));\n\t\t}\n\n\t\tawait this.withConcurrency(files, this.getWriteConcurrency(), async (filePath) => {\n\t\t\tconst content = await fs.readFile(filePath, \"utf8\");\n\t\t\tthis.#artifactByPath.set(filePath, content);\n\t\t});\n\t}\n\n\tprivate async collectFiles(rootDir: string): Promise<string[]> {\n\t\ttry {\n\t\t\tconst entries = await fs.readdir(rootDir, { withFileTypes: true });\n\t\t\tconst files: string[] = [];\n\t\t\tfor (const entry of entries) {\n\t\t\t\tconst fullPath = `${rootDir}/${entry.name}`;\n\t\t\t\tif (entry.isDirectory()) {\n\t\t\t\t\tfiles.push(...(await this.collectFiles(fullPath)));\n\t\t\t\t} else if (entry.isFile()) {\n\t\t\t\t\tfiles.push(fullPath);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn files;\n\t\t} catch {\n\t\t\treturn [];\n\t\t}\n\t}\n\n\tprivate getWriteConcurrency(): number {\n\t\tconst requested = Number(process.env.FORGE_WRITE_CONCURRENCY);\n\t\tif (Number.isFinite(requested) && requested > 0) {\n\t\t\treturn Math.floor(requested);\n\t\t}\n\t\treturn DEFAULT_WRITE_CONCURRENCY;\n\t}\n\n\tprivate startWorkers(): void {\n\t\tif (this.#workerError != null) {\n\t\t\treturn;\n\t\t}\n\t\tconst maxWorkers = this.getWriteConcurrency();\n\t\twhile (this.#activeWorkers < maxWorkers && this.#pendingWrites.length > 0) {\n\t\t\tthis.#activeWorkers += 1;\n\t\t\tvoid this.runWorker().finally(() => {\n\t\t\t\tthis.#activeWorkers -= 1;\n\t\t\t\tif (this.#pendingWrites.length > 0) {\n\t\t\t\t\tthis.startWorkers();\n\t\t\t\t} else if (this.#activeWorkers === 0) {\n\t\t\t\t\tthis.resolveDrain();\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t}\n\n\tprivate async runWorker(): Promise<void> {\n\t\twhile (true) {\n\t\t\tconst response = this.#pendingWrites.shift();\n\t\t\tif (response == null) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tif (this.#warmupPromise != null) {\n\t\t\t\t\tawait this.#warmupPromise;\n\t\t\t\t}\n\n\t\t\t\tconst outputPath = response.outputPath;\n\t\t\t\tif (outputPath == null) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tconst outputDir = response.outputDir;\n\t\t\t\tif (outputDir != null) {\n\t\t\t\t\tawait this.ensureDirectory(outputDir);\n\t\t\t\t}\n\n\t\t\t\tconst existing = this.#artifactByPath.get(outputPath);\n\t\t\t\tif (existing === response.code) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tawait io.writeFile(outputPath, response.code);\n\t\t\t\tthis.#artifactByPath.set(outputPath, response.code);\n\t\t\t} catch (error) {\n\t\t\t\tthis.#workerError = error;\n\t\t\t\tthis.#pendingWrites = [];\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate ensureDirectory(dir: string): Promise<void> {\n\t\tif (this.#ensuredDirs.has(dir)) {\n\t\t\treturn Promise.resolve();\n\t\t}\n\t\tconst existing = this.#ensureDirPromises.get(dir);\n\t\tif (existing != null) {\n\t\t\treturn existing;\n\t\t}\n\t\tconst mkdirPromise = fs.mkdir(dir, { recursive: true }).then(() => {\n\t\t\tthis.#ensuredDirs.add(dir);\n\t\t\tthis.#ensureDirPromises.delete(dir);\n\t\t});\n\t\tthis.#ensureDirPromises.set(dir, mkdirPromise);\n\t\treturn mkdirPromise;\n\t}\n\n\tprivate resolveDrain(): void {\n\t\tif (this.#pendingWrites.length > 0 || this.#activeWorkers > 0) {\n\t\t\treturn;\n\t\t}\n\t\tfor (const resolve of this.#drainResolvers) {\n\t\t\tresolve();\n\t\t}\n\t\tthis.#drainResolvers = [];\n\t}\n\n\tprivate async withConcurrency<T>(\n\t\titems: T[],\n\t\tconcurrency: number,\n\t\tworker: (item: T) => Promise<void>,\n\t): Promise<void> {\n\t\tlet cursor = 0;\n\t\tconst workerCount = Math.min(concurrency, items.length);\n\t\tconst workers = Array.from({ length: workerCount }, () =>\n\t\t\t(async () => {\n\t\t\t\twhile (true) {\n\t\t\t\t\tconst index = cursor;\n\t\t\t\t\tcursor += 1;\n\t\t\t\t\tif (index >= items.length) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tawait worker(items[index]);\n\t\t\t\t}\n\t\t\t})(),\n\t\t);\n\t\tawait Promise.all(workers);\n\t}\n}\n"],"names":["FileWriterService","DEFAULT_WRITE_CONCURRENCY","Map","Set","initialize","warmup","projects","outputDirs","getOutputDirs","signature","join","clear","undefined","loadExistingArtifacts","enqueueOutput","response","outcome","outputPath","push","startWorkers","enqueueOutputs","responses","flush","length","Promise","resolve","dirs","project","target","getForgeConfiguration","targets","add","getOutDir","sort","files","dir","collectFiles","withConcurrency","getWriteConcurrency","filePath","content","fs","readFile","set","rootDir","entries","readdir","withFileTypes","entry","fullPath","name","isDirectory","isFile","requested","Number","process","env","FORGE_WRITE_CONCURRENCY","isFinite","Math","floor","maxWorkers","runWorker","finally","resolveDrain","shift","outputDir","ensureDirectory","existing","get","code","io","writeFile","error","has","mkdirPromise","mkdir","recursive","then","delete","items","concurrency","worker","cursor","workerCount","min","workers","Array","from","index","all"],"mappings":"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"}

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

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SwcTranspiler", {
+    enumerable: true,
+    get: function() {
+        return SwcTranspiler;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _caching = require("@decohere/nexus/caching");
+const _diagnostics = require("@decohere/nexus/diagnostics");
+const _extensibility = require("@decohere/nexus/extensibility");
+const _io = require("@decohere/nexus/io");
+const _core = require("@swc/core");
+const _buildtargettype = require("../types/build-target.type.js");
+require("../extensions/project.extensions.js");
+const _swcconfigfactory = require("../factories/swc-config.factory.js");
+const _cachesoutputsmixin = require("../mixins/caches-outputs.mixin.js");
+const _incrementaltransformmixin = require("../mixins/incremental-transform.mixin.js");
+const _transformresponsemodel = require("../types/transform-response.model.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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);
+}
+class SwcTranspiler extends (0, _extensibility.mixwith)(_cachesoutputsmixin.CachesOutputs, _incrementaltransformmixin.IncrementalTransform) {
+    buildTargets = [
+        _buildtargettype.BuildTargets.es6,
+        _buildtargettype.BuildTargets.commonjs
+    ];
+    #swcConfigFactory = new _swcconfigfactory.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 !== _buildtargettype.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;
+    }
+    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 = _transformresponsemodel.TransformResponse.Skipped({
+                file,
+                messages: "File is empty",
+                config: swcOptions,
+                project
+            });
+            onOutput?.(skipped);
+            return skipped;
+        }
+        try {
+            const filePath = file.relativePath;
+            const extName = _nodepath.default.extname(filePath);
+            const fileName = filePath.replace(new RegExp(`${extName}$`), ".js");
+            const outBaseDir = project?.getOutDir(target);
+            const outputPath = outBaseDir ? _nodepath.default.join(outBaseDir, fileName) : undefined;
+            const outputDir = outputPath ? _nodepath.default.dirname(outputPath) : undefined;
+            const transformed = await (0, _core.transform)(content, swcOptions);
+            if (transformed == null) {
+                throw new Error("swc.transform returned no result");
+            }
+            const success = _transformresponsemodel.TransformResponse.Success({
+                file,
+                code: transformed.code,
+                target,
+                fileName,
+                outputDir,
+                outputPath,
+                config: swcOptions,
+                project
+            });
+            onOutput?.(success);
+            return success;
+        } catch (error) {
+            const failure = _transformresponsemodel.TransformResponse.Error({
+                file,
+                messages: [
+                    String(error)
+                ],
+                config: swcOptions,
+                project
+            });
+            onOutput?.(failure);
+            return failure;
+        }
+    }
+    async onIncrementalFileEvent(evt) {
+        const { file, project } = evt;
+        if (evt.eventName === _io.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([
+    (0, _caching.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([
+    (0, _caching.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([
+    _diagnostics.Trace
+], SwcTranspiler);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/projects/forge/src/services/swc-transpiler.ts"],"sourcesContent":["import 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 } 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\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":["SwcTranspiler","mixwith","CachesOutputs","IncrementalTransform","buildTargets","BuildTargets","es6","commonjs","SwcConfigFactory","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","baseConfig","createBaseConfig","file","swcOptions","createFileConfig","runTransform","content","getFileContent","skipped","TransformResponse","Skipped","messages","config","filePath","relativePath","extName","path","extname","fileName","replace","RegExp","outBaseDir","getOutDir","outputPath","join","undefined","outputDir","dirname","transformed","transform","Error","success","Success","code","error","failure","String","onIncrementalFileEvent","evt","eventName","io","WatchEvents","unlink","deleteCachedOutputs","fullPath","isSourceFile","invalidateContentCache","resolve","_file","getContent","prototype","name","keyFn","args"],"mappings":"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"}

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

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TsProgramHost", {
+    enumerable: true,
+    get: function() {
+        return TsProgramHost;
+    }
+});
+const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _caching = require("@decohere/nexus/caching");
+const _diagnostics = require("@decohere/nexus/diagnostics");
+const _typescript = require("typescript");
+const _typeemitter = require("./type-emitter.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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);
+}
+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 = (0, _typescript.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 (0, _typescript.createProgram)(filePaths, {
+            ..._typeemitter.DEFAULT_TYPE_EMITTER_OPTIONS,
+            ...compilerOptions,
+            ..._typeemitter.REQUIRED_TYPE_EMITTER_OPTIONS
+        }, host, oldProgram);
+    }
+    readFileFromDisk(fileName) {
+        try {
+            return _nodefs.default.readFileSync(fileName, "utf8");
+        } catch  {
+            return undefined;
+        }
+    }
+    fileExistsOnDisk(fileName) {
+        return _nodefs.default.existsSync(fileName);
+    }
+    directoryExists(directoryName) {
+        try {
+            return _nodefs.default.statSync(directoryName).isDirectory();
+        } catch  {
+            return false;
+        }
+    }
+    getDirectories(directoryName) {
+        try {
+            return _nodefs.default.readdirSync(directoryName, {
+                withFileTypes: true
+            }).filter((entry)=>entry.isDirectory()).map((entry)=>entry.name);
+        } catch  {
+            return [];
+        }
+    }
+}
+_ts_decorate([
+    (0, _caching.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([
+    (0, _caching.cache)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Boolean)
+], TsProgramHost.prototype, "fileExistsOnDisk", null);
+_ts_decorate([
+    (0, _caching.cache)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Boolean)
+], TsProgramHost.prototype, "directoryExists", null);
+_ts_decorate([
+    (0, _caching.cache)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Array)
+], TsProgramHost.prototype, "getDirectories", null);
+TsProgramHost = _ts_decorate([
+    _diagnostics.Trace
+], TsProgramHost);
+
+//# sourceMappingURL=data:application/json;base64,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