@typed/virtual-modules 1.0.0-beta.1

package/src/CompilerHostAdapter.test.ts

@@ -0,0 +1,180 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import ts from "typescript";
+import { afterEach, describe, expect, it } from "vitest";
+import { attachCompilerHostAdapter } from "./CompilerHostAdapter.js";
+import { PluginManager } from "./PluginManager.js";
+
+const tempDirs: string[] = [];
+
+const createTempDir = (): string => {
+  const dir = mkdtempSync(join(tmpdir(), "typed-vm-compiler-"));
+  tempDirs.push(dir);
+  return dir;
+};
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    const dir = tempDirs.pop();
+    if (dir) {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+});
+
+describe("attachCompilerHostAdapter", () => {
+  it("injects virtual modules into a Program graph", () => {
+    const dir = createTempDir();
+    const entry = join(dir, "entry.ts");
+
+    writeFileSync(
+      entry,
+      `
+import type { Foo } from "virtual:foo";
+export const value: Foo = { n: 1 };
+`,
+      "utf8",
+    );
+
+    const manager = new PluginManager([
+      {
+        name: "virtual",
+        shouldResolve: (id) => id === "virtual:foo",
+        build: () => `export interface Foo { n: number }`,
+      },
+    ]);
+
+    const compilerOptions: ts.CompilerOptions = {
+      strict: true,
+      noEmit: true,
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      skipLibCheck: true,
+    };
+    const host = ts.createCompilerHost(compilerOptions);
+    const adapter = attachCompilerHostAdapter({
+      ts,
+      compilerHost: host,
+      resolver: manager,
+      projectRoot: dir,
+    });
+
+    const program = ts.createProgram([entry], compilerOptions, host);
+    const diagnostics = ts.getPreEmitDiagnostics(program);
+
+    expect(diagnostics).toHaveLength(0);
+    expect(
+      program.getSourceFiles().some((sourceFile) => sourceFile.fileName.includes("__virtual_")),
+    ).toBe(true);
+
+    adapter.dispose();
+  });
+
+  it("evicts virtual record when importer no longer exists (fileExists returns false)", () => {
+    const dir = createTempDir();
+    const entry1 = join(dir, "entry1.ts");
+    const entry2 = join(dir, "entry2.ts");
+    writeFileSync(
+      entry1,
+      `import type { Foo } from "virtual:foo"; export const value: Foo = { n: 1 };`,
+      "utf8",
+    );
+    writeFileSync(
+      entry2,
+      `import type { Bar } from "virtual:bar"; export const value: Bar = { s: "x" };`,
+      "utf8",
+    );
+    const compilerOptions: ts.CompilerOptions = {
+      strict: true,
+      noEmit: true,
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      skipLibCheck: true,
+    };
+    const baseHost = ts.createCompilerHost(compilerOptions);
+    const missingPaths = new Set<string>();
+    const host = {
+      ...baseHost,
+      fileExists: (fileName: string) => {
+        if (missingPaths.has(fileName)) return false;
+        return baseHost.fileExists(fileName);
+      },
+    };
+    const manager = new PluginManager([
+      {
+        name: "virtual-foo",
+        shouldResolve: (id) => id === "virtual:foo",
+        build: () => `export interface Foo { n: number }`,
+      },
+      {
+        name: "virtual-bar",
+        shouldResolve: (id) => id === "virtual:bar",
+        build: () => `export interface Bar { s: string }`,
+      },
+    ]);
+    const adapter = attachCompilerHostAdapter({
+      ts,
+      compilerHost: host,
+      resolver: manager,
+      projectRoot: dir,
+    });
+    const program1 = ts.createProgram([entry1, entry2], compilerOptions, host);
+    const virtualFooFile = program1
+      .getSourceFiles()
+      .find((sf) => sf.fileName.includes("__virtual_") && sf.fileName.includes("virtual-foo"));
+    expect(virtualFooFile).toBeDefined();
+    const virtualFooFileName = virtualFooFile!.fileName;
+
+    missingPaths.add(entry1);
+    ts.createProgram([entry2], compilerOptions, host);
+    const afterEviction = host.getSourceFile(virtualFooFileName, ts.ScriptTarget.ESNext);
+    expect(afterEviction).toBeUndefined();
+
+    adapter.dispose();
+  });
+
+  it("dispose then getSourceFile does not throw and returns original behavior", () => {
+    const dir = createTempDir();
+    const entry = join(dir, "entry.ts");
+    writeFileSync(
+      entry,
+      `import type { Foo } from "virtual:foo"; export const value: Foo = { n: 1 };`,
+      "utf8",
+    );
+    const manager = new PluginManager([
+      {
+        name: "virtual",
+        shouldResolve: (id) => id === "virtual:foo",
+        build: () => `export interface Foo { n: number }`,
+      },
+    ]);
+    const compilerOptions: ts.CompilerOptions = {
+      strict: true,
+      noEmit: true,
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      skipLibCheck: true,
+    };
+    const host = ts.createCompilerHost(compilerOptions);
+    const adapter = attachCompilerHostAdapter({
+      ts,
+      compilerHost: host,
+      resolver: manager,
+      projectRoot: dir,
+    });
+    const program = ts.createProgram([entry], compilerOptions, host);
+    const virtualFile = program.getSourceFiles().find((sf) => sf.fileName.includes("__virtual_"));
+    expect(virtualFile).toBeDefined();
+    const virtualFileName = virtualFile!.fileName;
+
+    adapter.dispose();
+
+    expect(() => host.getSourceFile(virtualFileName, ts.ScriptTarget.ESNext)).not.toThrow();
+    const after = host.getSourceFile(virtualFileName, ts.ScriptTarget.ESNext);
+    expect(after).toBeUndefined();
+  });
+});

package/src/CompilerHostAdapter.ts

@@ -0,0 +1,316 @@
+import type * as ts from "typescript";
+import {
+  type CompilerHostAdapterOptions,
+  type VirtualModuleAdapterHandle,
+  type VirtualModuleDiagnostic,
+} from "./types.js";
+import { rewriteSourceForPreviewLocation } from "./internal/materializeVirtualFile.js";
+import {
+  createVirtualRecordStore,
+  toResolvedModule,
+  type MutableVirtualRecord,
+} from "./internal/VirtualRecordStore.js";
+import { VIRTUAL_NODE_MODULES_RELATIVE } from "./internal/path.js";
+
+export const attachCompilerHostAdapter = (
+  options: CompilerHostAdapterOptions,
+): VirtualModuleAdapterHandle => {
+  if (typeof options.projectRoot !== "string" || options.projectRoot.trim() === "") {
+    throw new Error("projectRoot must be a non-empty string");
+  }
+
+  const host = options.compilerHost as ts.CompilerHost & Record<string, unknown>;
+  const watchHost = options.watchHost;
+
+  const invalidatedPaths = new Set<string>();
+
+  const originalResolveModuleNameLiterals = (
+    host as {
+      resolveModuleNameLiterals?: (...args: readonly unknown[]) => readonly unknown[];
+    }
+  ).resolveModuleNameLiterals?.bind(host);
+  const originalResolveModuleNames = (
+    host as {
+      resolveModuleNames?: (
+        ...args: readonly unknown[]
+      ) => readonly (ts.ResolvedModule | undefined)[];
+    }
+  ).resolveModuleNames?.bind(host);
+  const originalGetSourceFile = host.getSourceFile.bind(host);
+  const originalGetSourceFileByPath = (
+    host as {
+      getSourceFileByPath?: (...args: readonly unknown[]) => ts.SourceFile | undefined;
+    }
+  ).getSourceFileByPath?.bind(host);
+  const originalFileExists = host.fileExists.bind(host);
+  const originalReadFile = host.readFile.bind(host);
+  const originalHasInvalidatedResolutions = (
+    host as {
+      hasInvalidatedResolutions?: (...args: readonly unknown[]) => boolean;
+    }
+  ).hasInvalidatedResolutions?.bind(host);
+
+  const store = createVirtualRecordStore({
+    projectRoot: options.projectRoot,
+    resolver: options.resolver,
+    createTypeInfoApiSession: options.createTypeInfoApiSession,
+    debounceMs: options.debounceMs,
+    watchHost,
+    shouldEvictRecord: (record) => !originalFileExists(record.importer),
+    onMarkStale: (record) => {
+      invalidatedPaths.add(record.importer);
+      invalidatedPaths.add(record.virtualFileName);
+    },
+    onRecordResolved: (record) => {
+      invalidatedPaths.delete(record.importer);
+      invalidatedPaths.delete(record.virtualFileName);
+    },
+    onEvictRecord: (record) => {
+      invalidatedPaths.delete(record.importer);
+      invalidatedPaths.delete(record.virtualFileName);
+    },
+  });
+
+  const { recordsByVirtualFile } = store;
+
+  const getOrBuildRecord = (id: string, importer: string): MutableVirtualRecord | undefined => {
+    const result = store.getOrBuildRecord(id, importer);
+    return result.status === "resolved" ? result.record : undefined;
+  };
+
+  const ADAPTER_DIAGNOSTIC_CODE = 99001;
+
+  const rebuildIfStale = (record: MutableVirtualRecord): MutableVirtualRecord => {
+    if (!record.stale) {
+      return record;
+    }
+
+    const rebuilt = store.resolveRecord(record.id, record.importer, record);
+    if (rebuilt.status === "resolved") {
+      return rebuilt.record;
+    }
+
+    if (rebuilt.status === "error" && options.reportDiagnostic) {
+      const diag = rebuilt.diagnostic as VirtualModuleDiagnostic;
+      const message = `Virtual module rebuild failed: ${diag.message}`;
+      options.reportDiagnostic({
+        category: options.ts.DiagnosticCategory.Error,
+        code: ADAPTER_DIAGNOSTIC_CODE,
+        file: undefined,
+        start: 0,
+        length: 0,
+        messageText: message,
+      });
+    }
+    return record;
+  };
+
+  const fallbackResolveModule = (
+    moduleName: string,
+    containingFile: string,
+    compilerOptions: ts.CompilerOptions | undefined,
+  ): ts.ResolvedModuleFull | undefined => {
+    const result = options.ts.resolveModuleName(
+      moduleName,
+      containingFile,
+      compilerOptions ?? {},
+      host,
+    );
+    return result.resolvedModule as ts.ResolvedModuleFull | undefined;
+  };
+
+  (host as ts.CompilerHost).resolveModuleNames = (
+    moduleNames: readonly string[],
+    containingFile: string,
+    reusedNames: readonly string[] | undefined,
+    redirectedReference: ts.ResolvedProjectReference | undefined,
+    compilerOptions: ts.CompilerOptions,
+    containingSourceFile?: ts.SourceFile,
+  ): (ts.ResolvedModule | undefined)[] => {
+    const fallback = originalResolveModuleNames
+      ? originalResolveModuleNames(
+          moduleNames,
+          containingFile,
+          reusedNames,
+          redirectedReference,
+          compilerOptions,
+          containingSourceFile,
+        )
+      : moduleNames.map((moduleName) =>
+          fallbackResolveModule(moduleName, containingFile, compilerOptions),
+        );
+
+    return moduleNames.map((moduleName, index) => {
+      const record = getOrBuildRecord(moduleName, containingFile);
+      if (!record) {
+        return fallback[index];
+      }
+      return toResolvedModule(options.ts, record.virtualFileName);
+    });
+  };
+
+  const assignResolveModuleNameLiterals = (
+    moduleLiterals: readonly { readonly text: string }[],
+    containingFile: string,
+    redirectedReference: ts.ResolvedProjectReference | undefined,
+    compilerOptions: ts.CompilerOptions,
+    containingSourceFile: ts.SourceFile | undefined,
+    reusedNames?: readonly { readonly text: string }[],
+  ): readonly ts.ResolvedModuleWithFailedLookupLocations[] => {
+    const fallback = originalResolveModuleNameLiterals
+      ? (originalResolveModuleNameLiterals(
+          moduleLiterals as unknown as readonly ts.StringLiteralLike[],
+          containingFile,
+          redirectedReference,
+          compilerOptions,
+          containingSourceFile,
+          reusedNames as readonly ts.StringLiteralLike[] | undefined,
+        ) as readonly ts.ResolvedModuleWithFailedLookupLocations[])
+      : moduleLiterals.map((moduleLiteral) => ({
+          resolvedModule: fallbackResolveModule(
+            moduleLiteral.text,
+            containingFile,
+            compilerOptions,
+          ),
+        }));
+
+    return moduleLiterals.map((moduleLiteral, index) => {
+      const record = getOrBuildRecord(moduleLiteral.text, containingFile);
+      if (!record) {
+        return fallback[index];
+      }
+
+      return {
+        resolvedModule: toResolvedModule(options.ts, record.virtualFileName),
+      };
+    });
+  };
+  (host as ts.CompilerHost).resolveModuleNameLiterals = assignResolveModuleNameLiterals;
+
+  const getSourceTextForRecord = (record: MutableVirtualRecord): string => {
+    const fresh = rebuildIfStale(record);
+    if (record.virtualFileName.includes(VIRTUAL_NODE_MODULES_RELATIVE)) {
+      return rewriteSourceForPreviewLocation(
+        fresh.sourceText,
+        fresh.importer,
+        record.virtualFileName,
+      );
+    }
+    return fresh.sourceText;
+  };
+
+  host.getSourceFile = (
+    fileName: string,
+    languageVersionOrOptions: ts.ScriptTarget | ts.CreateSourceFileOptions,
+    onError?: (message: string) => void,
+    shouldCreateNewSourceFile?: boolean,
+  ): ts.SourceFile | undefined => {
+    const record = recordsByVirtualFile.get(fileName);
+    if (!record) {
+      return originalGetSourceFile(
+        fileName,
+        languageVersionOrOptions,
+        onError,
+        shouldCreateNewSourceFile,
+      );
+    }
+
+    const sourceText = getSourceTextForRecord(record);
+    return options.ts.createSourceFile(
+      fileName,
+      sourceText,
+      languageVersionOrOptions as ts.ScriptTarget,
+      true,
+      options.ts.ScriptKind.TS,
+    );
+  };
+
+  if (originalGetSourceFileByPath) {
+    (host as ts.CompilerHost).getSourceFileByPath = (
+      fileName: string,
+      path: ts.Path,
+      languageVersionOrOptions: ts.ScriptTarget | ts.CreateSourceFileOptions,
+      onError?: (message: string) => void,
+      shouldCreateNewSourceFile?: boolean,
+    ): ts.SourceFile | undefined => {
+      const record = recordsByVirtualFile.get(fileName);
+      if (!record) {
+        return originalGetSourceFileByPath(
+          fileName,
+          path,
+          languageVersionOrOptions,
+          onError,
+          shouldCreateNewSourceFile,
+        );
+      }
+
+      const sourceText = getSourceTextForRecord(record);
+      return options.ts.createSourceFile(
+        fileName,
+        sourceText,
+        languageVersionOrOptions as ts.ScriptTarget,
+        true,
+        options.ts.ScriptKind.TS,
+      );
+    };
+  }
+
+  host.fileExists = (fileName: string): boolean => {
+    if (recordsByVirtualFile.has(fileName)) {
+      return true;
+    }
+
+    return originalFileExists(fileName);
+  };
+
+  host.readFile = (fileName: string): string | undefined => {
+    const record = recordsByVirtualFile.get(fileName);
+    if (!record) {
+      return originalReadFile(fileName);
+    }
+
+    return getSourceTextForRecord(record);
+  };
+
+  if (originalHasInvalidatedResolutions) {
+    (
+      host as { hasInvalidatedResolutions: (...args: readonly unknown[]) => boolean }
+    ).hasInvalidatedResolutions = (...args: readonly unknown[]) => {
+      if (invalidatedPaths.size > 0) {
+        return true;
+      }
+      return originalHasInvalidatedResolutions(...args);
+    };
+  }
+
+  return {
+    dispose(): void {
+      (
+        host as { resolveModuleNameLiterals?: (...args: readonly unknown[]) => readonly unknown[] }
+      ).resolveModuleNameLiterals = originalResolveModuleNameLiterals;
+      (
+        host as {
+          resolveModuleNames?: (
+            ...args: readonly unknown[]
+          ) => readonly (ts.ResolvedModule | undefined)[];
+        }
+      ).resolveModuleNames = originalResolveModuleNames;
+      host.getSourceFile = originalGetSourceFile;
+      if (originalGetSourceFileByPath) {
+        (
+          host as {
+            getSourceFileByPath?: (...args: readonly unknown[]) => ts.SourceFile | undefined;
+          }
+        ).getSourceFileByPath = originalGetSourceFileByPath;
+      }
+      host.fileExists = originalFileExists;
+      host.readFile = originalReadFile;
+      (
+        host as { hasInvalidatedResolutions?: (...args: readonly unknown[]) => boolean }
+      ).hasInvalidatedResolutions = originalHasInvalidatedResolutions;
+
+      store.dispose();
+      invalidatedPaths.clear();
+    },
+  };
+};