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

package/types/src/services/swc-transpiler.d.ts

@@ -1,10 +1,9 @@
-import type { Project, ProjectFileEvent, Tsconfig, Workspace } from "@decohere/mesh";
+import { type Project, type Tsconfig, type Workspace } from "@decohere/mesh";
 import type { FileEx } from "@decohere/nexus/io";
 import { type Options } from "@swc/core";
+import type { Observable } from "rxjs";
 import { type BuildTarget, type TranspileTarget } from "../types/build-target.type.js";
 import "../extensions/project.extensions.js";
-import { CachesOutputs } from "../mixins/caches-outputs.mixin.js";
-import { IncrementalTransform } from "../mixins/incremental-transform.mixin.js";
 import type { SwcConfig } from "../types/swc-config.type.js";
 import { TransformResponse } from "../types/transform-response.model.js";
 import type { Transformer } from "../types/transformer.type.js";
@@ -16,38 +15,33 @@ export type TranspileOptions = {
     workspace?: Workspace;
     projects?: readonly Project[];
 };
-declare const SwcTranspiler_base: abstract new (...args: unknown[]) => CachesOutputs & IncrementalTransform;
-export declare class SwcTranspiler extends SwcTranspiler_base implements Transformer {
+export declare class SwcTranspiler implements Transformer {
     #private;
     buildTargets: BuildTarget[];
+    get incrementalTransform$(): Observable<TransformResponse[]>;
     watch(workspace: Workspace): void;
     private withAliasContext;
     transformProject(projectArrayLike: Project | Project[], fileFilter?: (project: Project) => Promise<FileEx[]>, onOutput?: (response: TransformResponse) => void): Promise<TransformResponse[]>;
-    transformFile(fileArrayLike: FileEx[] | FileEx, buildTarget: TranspileTarget, options?: TranspileOptions): Promise<TransformResponse[]>;
     /**
      * The SWC options for one project and target, without a filename. Building them reads the
      * workspace's aliases and merges configs, so a caller that transpiles many files builds them
-     * once and passes them to {@link transformFileSync}.
+     * once and passes them to {@link transformCode}.
      */
     createBaseConfig(buildTarget: TranspileTarget, options?: TranspileOptions): Options;
+    /** Sync variant of {@link transformCode}, for the load hook, which cannot await (#514). */
+    transformCodeSync(content: string, file: FileEx, buildTarget: TranspileTarget, baseConfig: Options): TransformResponse;
     /**
-     * Synchronous, single-file variant of `transformFile`.
-     * Reads the file with `fs.readFileSync` and transpiles via `swc.transformSync`.
-     * Intended for callers that cannot await (e.g. Node.js `registerHooks` load hook).
-     * Pass `baseConfig` from {@link createBaseConfig} to skip rebuilding it for every file.
+     * Compiles `content` as the source of `file`, without reading the file: for callers that
+     * already hold the code, such as the Vitest plugin, which must compile what Vite passes it
+     * rather than an earlier read of the disk (#517). Async SWC, on the thread pool, so many
+     * calls in flight compile in parallel (#661). With a `project`, the response carries where
+     * the build writes the output.
      */
-    transformFileSync(file: FileEx, buildTarget: TranspileTarget, options?: TranspileOptions, baseConfig?: Options): TransformResponse;
-    /**
-     * Async variant of {@link transformFileSync}, with the same result for the same file. SWC
-     * runs it on libuv's thread pool, so many calls in flight compile in parallel (#661).
-     */
-    transformFileAsync(file: FileEx, buildTarget: TranspileTarget, options?: TranspileOptions, baseConfig?: Options): Promise<TransformResponse>;
+    transformCode(content: string, file: FileEx, buildTarget: TranspileTarget, baseConfig: Options, project?: Project): Promise<TransformResponse>;
     private static skippedEmpty;
     private static succeeded;
     private transformTarget;
-    private runTransform;
-    protected onIncrementalFileEvent(evt: ProjectFileEvent): Promise<TransformResponse[]>;
+    private onIncrementalFileEvent;
     invalidateContentCache(_file: FileEx): void;
     private getFileContent;
 }
-export {};

package/types/src/services/transpile-cache.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Where compiled code is cached on disk (#514), or null when caching is off:
+ *
+ * - `DECOHERE_CACHE=0` turns it off.
+ * - `DECOHERE_CACHE_DIR` puts it in that directory.
+ * - Otherwise `<root>/node_modules/.cache/decohere`, where tools keep caches, or when the
+ *   workspace has no `node_modules`, `$XDG_CACHE_HOME/decohere`, then the OS temp directory.
+ *
+ * Flux keeps its entries in the `flux` folder inside it; `forge clean` removes the folder.
+ */
+declare function directory(rootDir: string, env?: NodeJS.ProcessEnv): string | null;
+/** The SWC version compiling: part of every cache key, so upgrading SWC misses. */
+export declare const transpileCache: {
+    directory: typeof directory;
+    swcVersion: string;
+};
+export {};

package/types/src/services/type-emitter.d.ts

@@ -1,9 +1,8 @@
-import type { Project, ProjectFileEvent } from "@decohere/mesh";
+import type { Project, Workspace } from "@decohere/mesh";
 import type { FileEx } from "@decohere/nexus/io";
+import type { Observable } from "rxjs";
 import type ts from "typescript";
 import "../extensions/project.extensions.js";
-import { CachesOutputs } from "../mixins/caches-outputs.mixin.js";
-import { IncrementalTransform } from "../mixins/incremental-transform.mixin.js";
 import { type BuildTarget } from "../types/build-target.type.js";
 import type { TransformResponse } from "../types/transform-response.model.js";
 import type { Transformer } from "../types/transformer.type.js";
@@ -31,10 +30,11 @@ export type PrepareProgramsOptions = {
     includeAllProjects?: boolean;
     requiredCompilerOptions?: ts.CompilerOptions;
 };
-declare const TypeEmitter_base: abstract new (...args: unknown[]) => CachesOutputs & IncrementalTransform;
-export declare class TypeEmitter extends TypeEmitter_base implements Transformer {
+export declare class TypeEmitter implements Transformer {
     #private;
     buildTargets: BuildTarget[];
+    get incrementalTransform$(): Observable<TransformResponse[]>;
+    watch(workspace: Workspace): void;
     /**
      * Phase 1: fetch files, create TypeScript programs sequentially.
      * Called before transformProject() so that the heavy createProgram work
@@ -51,7 +51,6 @@ export declare class TypeEmitter extends TypeEmitter_base implements Transformer
         formatted: string;
     }>;
     private preparePrograms;
-    protected onIncrementalFileEvent(evt: ProjectFileEvent): Promise<TransformResponse[]>;
+    private onIncrementalFileEvent;
     private invalidateReadFileCache;
 }
-export {};

package/types/src/types/transform-response.model.d.ts

@@ -2,11 +2,6 @@ import type { Project } from "@decohere/mesh";
 import type { File } from "@decohere/nexus/io";
 import type { BuildTarget } from "./build-target.type.js";
 export type TransformOutcome = "success" | "failure" | "skipped";
-export declare const TransformOutcomes: {
-    success: "success";
-    failure: "failure";
-    skipped: "skipped";
-};
 type TransformResponseBase = {
     file: File;
     config: unknown;

package/types/src/types/transformer.type.d.ts

@@ -3,15 +3,6 @@ import type { FileEx } from "@decohere/nexus/io";
 import type { Observable } from "rxjs";
 import type { BuildTarget } from "../types/build-target.type.js";
 import type { TransformResponse } from "./transform-response.model.js";
-export type FileEvent = {
-    type: "changed" | "added";
-    file: FileEx;
-    project?: Project;
-} | {
-    type: "deleted";
-    file: FileEx;
-    project: Project;
-};
 export declare const TransformerKey: unique symbol;
 export interface Transformer {
     readonly buildTargets: BuildTarget[];

package/types/src/vitest/forge-build.plugin.d.ts

@@ -2,8 +2,6 @@ export type ForgeBuildOptions = {
     buildConfig?: string;
     logLevel?: string;
     workspaceRoot?: string;
-    /** Skip the build pre-warm entirely (e.g. when a pre-built artifact is already on disk). */
-    skipBuild?: boolean;
 };
 export declare function forgeBuild(options?: ForgeBuildOptions): {
     name: string;

package/commonjs/src/mixins/caches-outputs.mixin.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "CachesOutputs", {
-    enumerable: true,
-    get: function() {
-        return CachesOutputs;
-    }
-});
-const _io = require("@decohere/nexus/io");
-class CachesOutputs {
-    /** Maps source file fullPath -> output TransformResponses for cleanup in watch mode. */ get outputCache() {
-        const self = this;
-        if (self.__outputCache == null) {
-            self.__outputCache = new Map();
-        }
-        return self.__outputCache;
-    }
-    cacheOutputs(responses) {
-        const byFile = new Map();
-        for (const response of responses){
-            if (response.outcome !== "success") continue;
-            const group = byFile.get(response.file.fullPath) ?? [];
-            group.push(response);
-            byFile.set(response.file.fullPath, group);
-        }
-        for (const [fullPath, group] of byFile){
-            this.outputCache.set(fullPath, group);
-        }
-    }
-    deleteCachedOutputs(filePath) {
-        const outputs = this.outputCache.get(filePath);
-        if (outputs == null) return;
-        for (const response of outputs){
-            if (response.outputPath != null) {
-                void _io.io.deleteFile(response.outputPath);
-            }
-        }
-        this.outputCache.delete(filePath);
-    }
-}

package/commonjs/src/mixins/incremental-transform.mixin.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "IncrementalTransform", {
-    enumerable: true,
-    get: function() {
-        return IncrementalTransform;
-    }
-});
-const _rxjs = require("rxjs");
-// WeakMap avoids the private-field-in-mixin problem: private class fields (#x)
-// are not accessible when methods are copied onto a different class prototype.
-const subjects = new WeakMap();
-function getSubject(instance) {
-    let subject = subjects.get(instance);
-    if (subject == null) {
-        subject = new _rxjs.Subject();
-        subjects.set(instance, subject);
-    }
-    return subject;
-}
-class IncrementalTransform {
-    get incrementalTransform$() {
-        return getSubject(this).asObservable();
-    }
-    watch(workspace) {
-        workspace.projectFileChanged$.subscribe((evt)=>{
-            void this.onIncrementalFileEvent(evt).then((responses)=>{
-                getSubject(this).next(responses);
-            });
-        });
-    }
-}

package/es6/src/mixins/caches-outputs.mixin.js

@@ -1,32 +0,0 @@
-import { io } from "@decohere/nexus/io";
-export class CachesOutputs {
-    /** Maps source file fullPath -> output TransformResponses for cleanup in watch mode. */ get outputCache() {
-        const self = this;
-        if (self.__outputCache == null) {
-            self.__outputCache = new Map();
-        }
-        return self.__outputCache;
-    }
-    cacheOutputs(responses) {
-        const byFile = new Map();
-        for (const response of responses){
-            if (response.outcome !== "success") continue;
-            const group = byFile.get(response.file.fullPath) ?? [];
-            group.push(response);
-            byFile.set(response.file.fullPath, group);
-        }
-        for (const [fullPath, group] of byFile){
-            this.outputCache.set(fullPath, group);
-        }
-    }
-    deleteCachedOutputs(filePath) {
-        const outputs = this.outputCache.get(filePath);
-        if (outputs == null) return;
-        for (const response of outputs){
-            if (response.outputPath != null) {
-                void io.deleteFile(response.outputPath);
-            }
-        }
-        this.outputCache.delete(filePath);
-    }
-}

package/es6/src/mixins/incremental-transform.mixin.js

@@ -1,24 +0,0 @@
-import { Subject } from "rxjs";
-// WeakMap avoids the private-field-in-mixin problem: private class fields (#x)
-// are not accessible when methods are copied onto a different class prototype.
-const subjects = new WeakMap();
-function getSubject(instance) {
-    let subject = subjects.get(instance);
-    if (subject == null) {
-        subject = new Subject();
-        subjects.set(instance, subject);
-    }
-    return subject;
-}
-export class IncrementalTransform {
-    get incrementalTransform$() {
-        return getSubject(this).asObservable();
-    }
-    watch(workspace) {
-        workspace.projectFileChanged$.subscribe((evt)=>{
-            void this.onIncrementalFileEvent(evt).then((responses)=>{
-                getSubject(this).next(responses);
-            });
-        });
-    }
-}

package/types/src/mixins/caches-outputs.mixin.d.ts

@@ -1,7 +0,0 @@
-import type { TransformResponse } from "../types/transform-response.model.js";
-export declare abstract class CachesOutputs {
-    /** Maps source file fullPath -> output TransformResponses for cleanup in watch mode. */
-    protected get outputCache(): Map<string, TransformResponse[]>;
-    protected cacheOutputs(responses: TransformResponse[]): void;
-    protected deleteCachedOutputs(filePath: string): void;
-}

package/types/src/mixins/incremental-transform.mixin.d.ts

@@ -1,13 +0,0 @@
-import type { ProjectFileEvent, Workspace } from "@decohere/mesh";
-import type { Observable } from "rxjs";
-import type { TransformResponse } from "../types/transform-response.model.js";
-export declare abstract class IncrementalTransform {
-    get incrementalTransform$(): Observable<TransformResponse[]>;
-    watch(workspace: Workspace): void;
-    /**
-     * Called for every workspace file change. Implementations should invalidate
-     * any internal caches, perform the incremental transform, and return the results.
-     * Return an empty array for deletions or when no output is produced.
-     */
-    protected abstract onIncrementalFileEvent(evt: ProjectFileEvent): Promise<TransformResponse[]>;
-}