@decohere/forge 0.0.1-dev.5

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

@@ -0,0 +1,217 @@
+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;
+}
+import fs from "node:fs/promises";
+import { injectable } from "@decohere/crucible/decorators";
+import { Trace } from "@decohere/nexus/diagnostics";
+import { io } from "@decohere/nexus/io";
+import "../extensions/project.extensions.js";
+const DEFAULT_WRITE_CONCURRENCY = 16;
+export 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 fs.readFile(filePath, "utf8");
+            this.#artifactByPath.set(filePath, content);
+        });
+    }
+    async collectFiles(rootDir) {
+        try {
+            const entries = await fs.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.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 = fs.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([
+    Trace,
+    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":["fs","injectable","Trace","io","DEFAULT_WRITE_CONCURRENCY","FileWriterService","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","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","writeFile","error","has","mkdirPromise","mkdir","recursive","then","delete","items","concurrency","worker","cursor","workerCount","min","workers","Array","from","index","all"],"mappings":";;;;;;AAAA,OAAOA,QAAQ,mBAAmB;AAClC,SAASC,UAAU,QAAQ,gCAAgC;AAE3D,SAASC,KAAK,QAAQ,8BAA8B;AACpD,SAASC,EAAE,QAAQ,qBAAqB;AACxC,OAAO,sCAAsC;AAI7C,MAAMC,4BAA4B;AAIlC,OAAO,MAAMC;IACZ,CAAA,cAAe,GAAG,IAAIC,MAAsB;IAC5C,CAAA,eAAgB,GAAG,GAAG;IACtB,CAAA,aAAc,CAA4B;IAC1C,CAAA,WAAY,GAAG,MAAM;IACrB,CAAA,aAAc,GAAwB,EAAE,CAAC;IACzC,CAAA,aAAc,GAAG,EAAE;IACnB,CAAA,cAAe,GAAsB,EAAE,CAAC;IACxC,CAAA,WAAY,GAAG,IAAIC,MAAc;IACjC,CAAA,iBAAkB,GAAG,IAAID,MAA6B;IACtD,CAAA,WAAY,CAAU;IAEtB,MAAaE,aAA4B;QACxC,IAAI,IAAI,CAAC,CAAA,WAAY,EAAE;YACtB;QACD;QACA,IAAI,CAAC,CAAA,WAAY,GAAG;IACrB;IAEA,MAAaC,OAAOC,QAAmB,EAAiB;QACvD,MAAMC,aAAa,IAAI,CAACC,aAAa,CAACF;QACtC,MAAMG,YAAYF,WAAWG,IAAI,CAAC;QAClC,IAAID,cAAc,IAAI,CAAC,CAAA,eAAgB,IAAI,IAAI,CAAC,CAAA,aAAc,IAAI,MAAM;YACvE,OAAO,IAAI,CAAC,CAAA,aAAc;QAC3B;QAEA,IAAI,CAAC,CAAA,eAAgB,GAAGA;QACxB,IAAI,CAAC,CAAA,WAAY,CAACE,KAAK;QACvB,IAAI,CAAC,CAAA,iBAAkB,CAACA,KAAK;QAC7B,IAAI,CAAC,CAAA,WAAY,GAAGC;QACpB,IAAI,CAAC,CAAA,aAAc,GAAG,IAAI,CAACC,qBAAqB,CAACN;QACjD,OAAO,IAAI,CAAC,CAAA,aAAc;IAC3B;IAEOO,cAAcC,QAA2B,EAAQ;QACvD,IAAI,IAAI,CAAC,CAAA,WAAY,IAAI,MAAM;YAC9B;QACD;QACA,IAAIA,SAASC,OAAO,KAAK,aAAaD,SAASE,UAAU,IAAI,MAAM;YAClE;QACD;QACA,IAAI,CAAC,CAAA,aAAc,CAACC,IAAI,CAACH;QACzB,IAAI,CAACI,YAAY;IAClB;IAEOC,eAAeC,SAA8B,EAAQ;QAC3D,KAAK,MAAMN,YAAYM,UAAW;YACjC,IAAI,CAACP,aAAa,CAACC;QACpB;IACD;IAEA,MAAaO,QAAuB;QACnC,IAAI,IAAI,CAAC,CAAA,aAAc,IAAI,MAAM;YAChC,MAAM,IAAI,CAAC,CAAA,aAAc;QAC1B;QACA,IAAI,IAAI,CAAC,CAAA,aAAc,CAACC,MAAM,KAAK,KAAK,IAAI,CAAC,CAAA,aAAc,KAAK,GAAG;YAClE;QACD;QACA,MAAM,IAAIC,QAAc,CAACC;YACxB,IAAI,CAAC,CAAA,cAAe,CAACP,IAAI,CAACO;QAC3B;QACA,IAAI,IAAI,CAAC,CAAA,WAAY,IAAI,MAAM;YAC9B,MAAM,IAAI,CAAC,CAAA,WAAY;QACxB;IACD;IAEQjB,cAAcF,QAAmB,EAAY;QACpD,MAAMoB,OAAO,IAAIvB;QACjB,KAAK,MAAMwB,WAAWrB,SAAU;YAC/B,KAAK,MAAMsB,UAAUD,QAAQE,qBAAqB,GAAGC,OAAO,CAAE;gBAC7DJ,KAAKK,GAAG,CAACJ,QAAQK,SAAS,CAACJ;YAC5B;QACD;QACA,OAAO;eAAIF;SAAK,CAACO,IAAI;IACtB;IAEA,MAAcpB,sBAAsBN,UAAoB,EAAiB;QACxE,IAAI,CAAC,CAAA,cAAe,CAACI,KAAK;QAE1B,MAAMuB,QAAkB,EAAE;QAC1B,KAAK,MAAMC,OAAO5B,WAAY;YAC7B2B,MAAMhB,IAAI,IAAK,MAAM,IAAI,CAACkB,YAAY,CAACD;QACxC;QAEA,MAAM,IAAI,CAACE,eAAe,CAACH,OAAO,IAAI,CAACI,mBAAmB,IAAI,OAAOC;YACpE,MAAMC,UAAU,MAAM5C,GAAG6C,QAAQ,CAACF,UAAU;YAC5C,IAAI,CAAC,CAAA,cAAe,CAACG,GAAG,CAACH,UAAUC;QACpC;IACD;IAEA,MAAcJ,aAAaO,OAAe,EAAqB;QAC9D,IAAI;YACH,MAAMC,UAAU,MAAMhD,GAAGiD,OAAO,CAACF,SAAS;gBAAEG,eAAe;YAAK;YAChE,MAAMZ,QAAkB,EAAE;YAC1B,KAAK,MAAMa,SAASH,QAAS;gBAC5B,MAAMI,WAAW,GAAGL,QAAQ,CAAC,EAAEI,MAAME,IAAI,EAAE;gBAC3C,IAAIF,MAAMG,WAAW,IAAI;oBACxBhB,MAAMhB,IAAI,IAAK,MAAM,IAAI,CAACkB,YAAY,CAACY;gBACxC,OAAO,IAAID,MAAMI,MAAM,IAAI;oBAC1BjB,MAAMhB,IAAI,CAAC8B;gBACZ;YACD;YACA,OAAOd;QACR,EAAE,OAAM;YACP,OAAO,EAAE;QACV;IACD;IAEQI,sBAA8B;QACrC,MAAMc,YAAYC,OAAOC,QAAQC,GAAG,CAACC,uBAAuB;QAC5D,IAAIH,OAAOI,QAAQ,CAACL,cAAcA,YAAY,GAAG;YAChD,OAAOM,KAAKC,KAAK,CAACP;QACnB;QACA,OAAOpD;IACR;IAEQmB,eAAqB;QAC5B,IAAI,IAAI,CAAC,CAAA,WAAY,IAAI,MAAM;YAC9B;QACD;QACA,MAAMyC,aAAa,IAAI,CAACtB,mBAAmB;QAC3C,MAAO,IAAI,CAAC,CAAA,aAAc,GAAGsB,cAAc,IAAI,CAAC,CAAA,aAAc,CAACrC,MAAM,GAAG,EAAG;YAC1E,IAAI,CAAC,CAAA,aAAc,IAAI;YACvB,KAAK,IAAI,CAACsC,SAAS,GAAGC,OAAO,CAAC;gBAC7B,IAAI,CAAC,CAAA,aAAc,IAAI;gBACvB,IAAI,IAAI,CAAC,CAAA,aAAc,CAACvC,MAAM,GAAG,GAAG;oBACnC,IAAI,CAACJ,YAAY;gBAClB,OAAO,IAAI,IAAI,CAAC,CAAA,aAAc,KAAK,GAAG;oBACrC,IAAI,CAAC4C,YAAY;gBAClB;YACD;QACD;IACD;IAEA,MAAcF,YAA2B;QACxC,MAAO,KAAM;YACZ,MAAM9C,WAAW,IAAI,CAAC,CAAA,aAAc,CAACiD,KAAK;YAC1C,IAAIjD,YAAY,MAAM;gBACrB;YACD;YAEA,IAAI;gBACH,IAAI,IAAI,CAAC,CAAA,aAAc,IAAI,MAAM;oBAChC,MAAM,IAAI,CAAC,CAAA,aAAc;gBAC1B;gBAEA,MAAME,aAAaF,SAASE,UAAU;gBACtC,IAAIA,cAAc,MAAM;oBACvB;gBACD;gBAEA,MAAMgD,YAAYlD,SAASkD,SAAS;gBACpC,IAAIA,aAAa,MAAM;oBACtB,MAAM,IAAI,CAACC,eAAe,CAACD;gBAC5B;gBAEA,MAAME,WAAW,IAAI,CAAC,CAAA,cAAe,CAACC,GAAG,CAACnD;gBAC1C,IAAIkD,aAAapD,SAASsD,IAAI,EAAE;oBAC/B;gBACD;gBAEA,MAAMtE,GAAGuE,SAAS,CAACrD,YAAYF,SAASsD,IAAI;gBAC5C,IAAI,CAAC,CAAA,cAAe,CAAC3B,GAAG,CAACzB,YAAYF,SAASsD,IAAI;YACnD,EAAE,OAAOE,OAAO;gBACf,IAAI,CAAC,CAAA,WAAY,GAAGA;gBACpB,IAAI,CAAC,CAAA,aAAc,GAAG,EAAE;gBACxB;YACD;QACD;IACD;IAEQL,gBAAgB/B,GAAW,EAAiB;QACnD,IAAI,IAAI,CAAC,CAAA,WAAY,CAACqC,GAAG,CAACrC,MAAM;YAC/B,OAAOX,QAAQC,OAAO;QACvB;QACA,MAAM0C,WAAW,IAAI,CAAC,CAAA,iBAAkB,CAACC,GAAG,CAACjC;QAC7C,IAAIgC,YAAY,MAAM;YACrB,OAAOA;QACR;QACA,MAAMM,eAAe7E,GAAG8E,KAAK,CAACvC,KAAK;YAAEwC,WAAW;QAAK,GAAGC,IAAI,CAAC;YAC5D,IAAI,CAAC,CAAA,WAAY,CAAC7C,GAAG,CAACI;YACtB,IAAI,CAAC,CAAA,iBAAkB,CAAC0C,MAAM,CAAC1C;QAChC;QACA,IAAI,CAAC,CAAA,iBAAkB,CAACO,GAAG,CAACP,KAAKsC;QACjC,OAAOA;IACR;IAEQV,eAAqB;QAC5B,IAAI,IAAI,CAAC,CAAA,aAAc,CAACxC,MAAM,GAAG,KAAK,IAAI,CAAC,CAAA,aAAc,GAAG,GAAG;YAC9D;QACD;QACA,KAAK,MAAME,WAAW,IAAI,CAAC,CAAA,cAAe,CAAE;YAC3CA;QACD;QACA,IAAI,CAAC,CAAA,cAAe,GAAG,EAAE;IAC1B;IAEA,MAAcY,gBACbyC,KAAU,EACVC,WAAmB,EACnBC,MAAkC,EAClB;QAChB,IAAIC,SAAS;QACb,MAAMC,cAAcxB,KAAKyB,GAAG,CAACJ,aAAaD,MAAMvD,MAAM;QACtD,MAAM6D,UAAUC,MAAMC,IAAI,CAAC;YAAE/D,QAAQ2D;QAAY,GAAG,IACnD,AAAC,CAAA;gBACA,MAAO,KAAM;oBACZ,MAAMK,QAAQN;oBACdA,UAAU;oBACV,IAAIM,SAAST,MAAMvD,MAAM,EAAE;wBAC1B;oBACD;oBACA,MAAMyD,OAAOF,KAAK,CAACS,MAAM;gBAC1B;YACD,CAAA;QAED,MAAM/D,QAAQgE,GAAG,CAACJ;IACnB;AACD"}

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

@@ -0,0 +1,161 @@
+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 { 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 } 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;
+    }
+    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":["/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":["path","cache","invalidateCache","Trace","mixwith","io","transform","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","baseConfig","createBaseConfig","file","swcOptions","createFileConfig","runTransform","content","getFileContent","skipped","Skipped","messages","config","filePath","relativePath","extName","extname","fileName","replace","RegExp","outBaseDir","getOutDir","outputPath","join","undefined","outputDir","dirname","transformed","Error","success","Success","code","error","failure","String","onIncrementalFileEvent","evt","eventName","WatchEvents","unlink","deleteCachedOutputs","fullPath","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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