@decohere/forge 0.0.1-dev.111 → 0.0.1-dev.113

package/commonjs/src/services/type-emitter.js

@@ -24,11 +24,10 @@ _export(exports, {
 });
 const _caching = require("@decohere/nexus/caching");
 const _diagnostics = require("@decohere/nexus/diagnostics");
-const _extensibility = require("@decohere/nexus/extensibility");
 const _io = require("@decohere/nexus/io");
 require("../extensions/project.extensions.js");
-const _cachesoutputsmixin = require("../mixins/caches-outputs.mixin.js");
-const _incrementaltransformmixin = require("../mixins/incremental-transform.mixin.js");
+const _incrementalwatch = require("./incremental-watch.js");
+const _outputcache = require("./output-cache.js");
 const _tsprogramhost = require("./ts-program-host.js");
 const _typeemissionprogram = require("./type-emission-program.js");
 const _buildtargettype = require("../types/build-target.type.js");
@@ -55,12 +54,20 @@ const REQUIRED_TYPE_EMITTER_OPTIONS = {
 const REQUIRED_TYPE_CHECK_OPTIONS = {
     noEmit: true
 };
-class TypeEmitter extends (0, _extensibility.mixwith)(_cachesoutputsmixin.CachesOutputs, _incrementaltransformmixin.IncrementalTransform) {
+class TypeEmitter {
     buildTargets = [
         _buildtargettype.BuildTargets.types
     ];
     /** Prepared programs from init(), consumed once by the next transformProject() call. */ #programs;
     #host = new _tsprogramhost.TsProgramHost();
+    #outputs = new _outputcache.OutputCache();
+    #incremental = new _incrementalwatch.IncrementalWatch();
+    get incrementalTransform$() {
+        return this.#incremental.results$;
+    }
+    watch(workspace) {
+        this.#incremental.watch(workspace, (evt)=>this.onIncrementalFileEvent(evt));
+    }
     /**
 	 * Phase 1: fetch files, create TypeScript programs sequentially.
 	 * Called before transformProject() so that the heavy createProgram work
@@ -79,7 +86,7 @@ class TypeEmitter extends (0, _extensibility.mixwith)(_cachesoutputsmixin.Caches
             return [];
         }
         const responses = (await Promise.all(programs.map((program)=>program.emit(filter, onOutput)))).flat();
-        this.cacheOutputs(responses);
+        this.#outputs.record(responses);
         return responses;
     }
     /**
@@ -133,7 +140,7 @@ class TypeEmitter extends (0, _extensibility.mixwith)(_cachesoutputsmixin.Caches
     async onIncrementalFileEvent(evt) {
         const { file, project } = evt;
         if (evt.eventName === _io.io.WatchEvents.unlink) {
-            this.deleteCachedOutputs(file.fullPath);
+            this.#outputs.delete(file.fullPath);
             return [];
         }
         if (!project.isSourceFile(file)) {

package/commonjs/src/types/transform-response.model.js

@@ -2,25 +2,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get TransformOutcomes () {
-        return TransformOutcomes;
-    },
-    get TransformResponse () {
+Object.defineProperty(exports, "TransformResponse", {
+    enumerable: true,
+    get: function() {
         return TransformResponse;
     }
 });
-const TransformOutcomes = {
-    success: "success",
-    failure: "failure",
-    skipped: "skipped"
-};
 class TransformResponse {
     static Success(data) {
         return new TransformResponse({

package/commonjs/src/vitest/forge-build.plugin.js

@@ -24,11 +24,6 @@ function _interop_require_default(obj) {
 // Above fatal (60) so all standard levels are nooped when logLevel is "silent"
 const SILENT_LEVEL = 999;
 const PLUGIN_NAME = "forge-vitest-source";
-const TS_EXTENSIONS = [
-    ".ts",
-    ".tsx",
-    ".mts"
-];
 function forgeBuild(options) {
     const buildConfig = options?.buildConfig ?? "debug";
     const workspaceRoot = options?.workspaceRoot ?? process.cwd();
@@ -43,9 +38,11 @@ function forgeBuild(options) {
         }
     });
     const logger = loggerFactory(PLUGIN_NAME);
-    const skipBuild = options?.skipBuild ?? false;
     const transpiler = new _swctranspiler.SwcTranspiler();
-    const warmedProjects = new Set();
+    /**
+	 * SWC options per project (tsconfig, `.swcrc`, path aliases), built once: rebuilding them for
+	 * every file was most of the plugin's per-file cost, as it was in flux (#513, #517).
+	 */ const baseConfigs = new Map();
     const transformCache = new Map();
     let workspace = null;
     const initWorkspace = async ()=>{
@@ -56,10 +53,17 @@ function forgeBuild(options) {
             rootDir: workspaceRoot
         });
     };
-    const preWarmProject = (project)=>{
-        if (warmedProjects.has(project.projectDirectory)) return;
-        warmedProjects.add(project.projectDirectory);
-        void transpiler.transformProject(project).then(()=>logger.debug(`Pre-warm complete for ${project.name}`)).catch((err)=>logger.error(`Pre-warm error for ${project.name}: ${err.message}`));
+    const baseConfigFor = (project)=>{
+        const cached = baseConfigs.get(project);
+        if (cached != null) return cached;
+        const config = transpiler.createBaseConfig(_buildtargettype.BuildTargets.es6, {
+            aliasPaths: true,
+            tsConfig: project?.getTsConfigSync(),
+            userConfig: project?.getSwcConfigSync(),
+            workspace: workspace ?? undefined
+        });
+        baseConfigs.set(project, config);
+        return config;
     };
     return {
         name: PLUGIN_NAME,
@@ -68,51 +72,32 @@ function forgeBuild(options) {
             logger.debug("Plugin loaded");
         },
         resolveId (source, importer) {
-            if (importer != null && source.endsWith(".js") && source.startsWith(".")) {
-                const importerDirectory = _nodepath.default.dirname(importer);
-                const withoutExtension = source.slice(0, -3);
-                const candidates = TS_EXTENSIONS.map((ext)=>_nodepath.default.resolve(importerDirectory, `${withoutExtension}${ext}`));
-                return candidates.find((c)=>(0, _nodefs.existsSync)(c)) ?? null;
+            // `./a.js` is `a.ts` or `a.tsx`, `./a.mjs` is `a.mts`, `./a.cjs` is `a.cts` (#518).
+            if (importer != null && /\.[mc]?jsx?$/.test(source) && source.startsWith(".")) {
+                const written = _nodepath.default.resolve(_nodepath.default.dirname(importer), source);
+                return _mesh.sourceExtensions.candidates(written).find((c)=>(0, _nodefs.existsSync)(c)) ?? null;
             }
             return null;
         },
         watchChange (id) {
-            const file = new _io.FileEx({
-                fullPath: id
-            });
             transformCache.delete(id);
-            transpiler.invalidateContentCache(file);
         },
         async transform (code, id) {
             if (id.includes("node_modules") || !/[.](ts|tsx|mts|cts)$/.test(id)) {
                 return null;
             }
-            await initWorkspace();
-            const project = await workspace?.findProject(id, buildConfig);
-            if (project != null && !skipBuild) {
-                preWarmProject(project);
-            }
             const cached = transformCache.get(id);
             if (cached !== undefined && cached.content === code) {
                 return cached.result;
             }
-            const file = new _io.FileEx({
+            await initWorkspace();
+            const project = await workspace?.findProject(id, buildConfig);
+            // The code Vite passes, not a read of the file: no content cache can serve an older
+            // version, and there is no pre-warm compiling files ahead from disk (#517).
+            const response = await transpiler.transformCode(code, new _io.FileEx({
                 fullPath: id,
                 content: code
-            });
-            if (cached !== undefined) {
-                // Content changed for a previously-seen file — invalidate the transpiler's
-                // FILE_CONTENT cache so the fresh content from Vite is used.
-                // The VS Code Vitest extension disables Vite's chokidar watcher
-                // (server.watch: null) and drives re-runs via vitest.watcher.onFileChange(),
-                // bypassing watchChange entirely — so we cannot rely on watchChange alone.
-                transpiler.invalidateContentCache(file);
-            }
-            const [response] = await transpiler.transformFile(file, _buildtargettype.BuildTargets.es6, {
-                aliasPaths: true,
-                tsConfig: project ? await project.getTsConfig() : undefined,
-                workspace: workspace ?? undefined
-            });
+            }), _buildtargettype.BuildTargets.es6, baseConfigFor(project));
             if (!response || response.outcome !== "success") return null;
             const result = {
                 code: response.code,

package/es6/src/actions/index.js

@@ -7,6 +7,7 @@ export * from "./dependency-sync.action.js";
 export * from "./docker.action.js";
 export * from "./link.action.js";
 export * from "./package.action.js";
+export * from "./paths.action.js";
 export * from "./publish.action.js";
 export * from "./sync-lock-file.action.js";
 export * from "./tag.action.js";

package/es6/src/actions/paths.action.js

@@ -0,0 +1,86 @@
+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 { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { injectable } from "@decohere/crucible/decorators";
+import { packageAliases, Workspace } from "@decohere/mesh";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { scribe } from "@decohere/scribe";
+export const PATHS_FILE = "tsconfig.paths.json";
+export class Paths {
+    workspace;
+    #logger = scribe.logger(Paths.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        const file = path.join(this.workspace.rootDir, PATHS_FILE);
+        const content = Paths.render(this.workspace);
+        const current = existsSync(file) ? await readFile(file, "utf8") : null;
+        const changed = current !== content;
+        if (options.check) {
+            if (!changed) {
+                return ActionResponse.Success(Paths.name, [
+                    {
+                        file,
+                        changed,
+                        succeeded: true
+                    }
+                ]);
+            }
+            const error = `${PATHS_FILE} is out of date. Run \`forge paths\` to update it.`;
+            this.#logger.error(error);
+            return ActionResponse.Error(Paths.name, [
+                {
+                    file,
+                    changed,
+                    succeeded: false,
+                    error
+                }
+            ]);
+        }
+        if (changed) {
+            await writeFile(file, content);
+            this.#logger.info(`Wrote ${PATHS_FILE}`);
+        }
+        return ActionResponse.Success(Paths.name, [
+            {
+                file,
+                changed,
+                succeeded: true
+            }
+        ]);
+    }
+    /** The file's content: convention and exported subpaths only, never the tsconfig's own paths. */ static render(workspace) {
+        const rootDir = path.resolve(workspace.rootDir);
+        const { paths } = packageAliases.build(workspace.getProjects("debug"), {
+            baseUrl: rootDir
+        });
+        const sorted = Object.fromEntries(Object.keys(paths).sort().map((key)=>[
+                key,
+                (paths[key] ?? []).map((target)=>`./${target}`)
+            ]));
+        const json = {
+            $comment: "Generated by `forge paths` from the workspace packages. Do not edit.",
+            compilerOptions: {
+                paths: sorted
+            }
+        };
+        return `${JSON.stringify(json, null, 2)}\n`;
+    }
+}
+Paths = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace
+    ])
+], Paths);

package/es6/src/commands/index.js

@@ -4,6 +4,7 @@ export * from "./docker.command.js";
 export * from "./forge.command.js";
 export * from "./link.command.js";
 export * from "./package.command.js";
+export * from "./paths.command.js";
 export * from "./publish.command.js";
 export * from "./tag.command.js";
 export * from "./typecheck.command.js";

package/es6/src/commands/paths.command.js

@@ -0,0 +1,14 @@
+import { DecohereCommand } from "@decohere/nexus/cli";
+import { Paths } from "../actions/paths.action.js";
+export class PathsCommand extends DecohereCommand {
+    get actions() {
+        return [
+            Paths
+        ];
+    }
+    constructor(name){
+        super(name);
+        this.description("Write tsconfig.paths.json: tsconfig paths for the workspace packages and their exported subpaths");
+        this.option("--check", "Fail if tsconfig.paths.json is missing or out of date", false);
+    }
+}

package/es6/src/extensions/project.extensions.js

@@ -37,7 +37,7 @@ export class ProjectExtensions {
     }
     static swcConfigPaths(project) {
         return [
-            path.join(project.projectDirectory, SWC_CONFIG),
+            path.join(project.projectRoot, SWC_CONFIG),
             path.join(project.rootDir, SWC_CONFIG)
         ];
     }

package/es6/src/factories/swc-config.factory.js

@@ -58,9 +58,18 @@ export class SwcConfigFactory {
             mergeArrays: false
         }, defaultOptions, options, userConfig ?? {});
     }
-    /** Stamps a per-file filename onto a pre-built base config. */ createFileConfig(file, baseConfig) {
+    /** Stamps a per-file filename onto a pre-built base config; `.tsx` also turns on JSX (#518). */ createFileConfig(file, baseConfig) {
+        const tsx = file.fullPath.endsWith(".tsx");
+        const jsc = tsx && baseConfig.jsc?.parser?.syntax === "typescript" ? {
+            ...baseConfig.jsc,
+            parser: {
+                ...baseConfig.jsc.parser,
+                tsx: true
+            }
+        } : baseConfig.jsc;
         const config = {
             ...baseConfig,
+            jsc,
             filename: file.fullPath
         };
         this.validate(config);

package/es6/src/forge.module.js

@@ -25,6 +25,7 @@ export class ForgeModule extends ModuleManifest {
         reportDependencies: Actions.ReportDependencies,
         version: Actions.Version,
         tag: Actions.Tag,
+        paths: Actions.Paths,
         typecheck: Actions.TypeCheck,
         commitFiles: Actions.CommitFiles,
         link: Actions.Link,
@@ -38,6 +39,7 @@ export class ForgeModule extends ModuleManifest {
         package: Commands.PackageCommand,
         version: Commands.VersionCommand,
         tag: Commands.TagCommand,
+        paths: Commands.PathsCommand,
         typecheck: Commands.TypeCheckCommand,
         link: Commands.LinkCommand,
         unlink: Commands.UnlinkCommand

package/es6/src/index.js

@@ -2,5 +2,6 @@ export { createWorkspace } from "./create-workspace.js";
 export { ForgeError } from "./errors.js";
 export { ForgeModule } from "./forge.module.js";
 export { SwcTranspiler } from "./services/swc-transpiler.js";
+export { transpileCache } from "./services/transpile-cache.js";
 export { BuildTargets } from "./types/build-target.type.js";
 export { Debug as DebugConfiguration, DefaultConfigurations, Link as LinkConfiguration, Release as ReleaseConfiguration, WorkspaceDefaults } from "./workspace.config.js";

package/es6/src/packaging/release-exports.js

@@ -1,11 +1,13 @@
+import { sourceExtensions } from "@decohere/mesh";
 const ES6_PREFIX = "./es6/";
 /** Condition names that can point at runnable ESM, most specific first. `types` never does. */ const RUNTIME_CONDITIONS = [
     "import",
     "node",
     "default"
 ];
-/** `src/main.ts` becomes `src/main.js`, with any leading `./` dropped. */ function toJs(filePath) {
-    return filePath.replace(/^\.\//, "").replace(/\.ts$/, ".js").replace(/\.mts$/, ".mjs");
+/** `src/main.ts` becomes `src/main.js` (`.mts` `.mjs`, `.cts` `.cjs`), with any leading `./` dropped. */ function toJs(filePath) {
+    const file = filePath.replace(/^\.\//, "");
+    return sourceExtensions.isSource(file) ? sourceExtensions.outputPath(file) : file;
 }
 /**
  * The `exports` a library needs once only its `es6/` output is shipped: the library's own

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

@@ -14,19 +14,12 @@ 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("|");

package/es6/src/services/incremental-watch.js

@@ -0,0 +1,18 @@
+import { Subject } from "rxjs";
+/**
+ * Runs a transformer's handler for every workspace file change and emits what it built. The
+ * handler invalidates the transformer's own caches, rebuilds, and returns the responses (empty
+ * for a deletion or when nothing was built).
+ */ export class IncrementalWatch {
+    #results = new Subject();
+    get results$() {
+        return this.#results.asObservable();
+    }
+    watch(workspace, handler) {
+        workspace.projectFileChanged$.subscribe((evt)=>{
+            void handler(evt).then((responses)=>{
+                this.#results.next(responses);
+            });
+        });
+    }
+}

package/es6/src/services/output-cache.js

@@ -0,0 +1,29 @@
+import { io } from "@decohere/nexus/io";
+/** The outputs each source file last built to, so watch mode can delete them when it goes. */ export class OutputCache {
+    #bySource = new Map();
+    get(sourcePath) {
+        return this.#bySource.get(sourcePath);
+    }
+    /** Records the successful outputs, replacing what each of their source files had before. */ record(responses) {
+        const bySource = new Map();
+        for (const response of responses){
+            if (response.outcome !== "success") continue;
+            const group = bySource.get(response.file.fullPath) ?? [];
+            group.push(response);
+            bySource.set(response.file.fullPath, group);
+        }
+        for (const [sourcePath, group] of bySource){
+            this.#bySource.set(sourcePath, group);
+        }
+    }
+    /** Deletes the files a source built to and forgets them. */ delete(sourcePath) {
+        const outputs = this.#bySource.get(sourcePath);
+        if (outputs == null) return;
+        for (const response of outputs){
+            if (response.outputPath != null) {
+                void io.deleteFile(response.outputPath);
+            }
+        }
+        this.#bySource.delete(sourcePath);
+    }
+}