@typed/virtual-modules-compiler 1.0.0-beta.1

package/dist/watch.js

@@ -0,0 +1,61 @@
+import { mkdirSync } from "node:fs";
+import { attachCompilerHostAdapter, createTypeInfoApiSessionFactory, ensureTypeTargetBootstrapFile, } from "@typed/virtual-modules";
+/**
+ * Run the compiler in watch mode. Mirrors tsc --watch.
+ */
+export function runWatch(params) {
+    const { ts, commandLine, resolver, reportDiagnostic, reportWatchStatus, typeTargetSpecs } = params;
+    const { options, fileNames, projectReferences, watchOptions } = commandLine;
+    const sys = ts.sys;
+    if (!sys) {
+        reportDiagnostic(createDiagnostic(ts, ts.DiagnosticCategory.Error, 0, 0, "ts.sys is not available."));
+        process.exit(1);
+    }
+    const projectRoot = sys.getCurrentDirectory();
+    let effectiveFileNames = fileNames;
+    if (typeTargetSpecs && typeTargetSpecs.length > 0) {
+        const bootstrapPath = ensureTypeTargetBootstrapFile(projectRoot, typeTargetSpecs, {
+            mkdirSync,
+            writeFile: (path, content) => sys.writeFile(path, content),
+        });
+        effectiveFileNames = fileNames.includes(bootstrapPath)
+            ? fileNames
+            : [...fileNames, bootstrapPath];
+    }
+    const preliminaryHost = ts.createCompilerHost(options);
+    const preliminaryProgram = ts.createProgram({
+        rootNames: effectiveFileNames,
+        options,
+        host: preliminaryHost,
+        projectReferences,
+    });
+    const createTypeInfoApiSession = createTypeInfoApiSessionFactory({
+        ts,
+        program: preliminaryProgram,
+        ...(typeTargetSpecs?.length ? { typeTargetSpecs } : {}),
+    });
+    const createProgram = (rootNames, opts, host, oldProgram, configFileParsingDiagnostics, refs) => {
+        if (!host) {
+            host = ts.createCompilerHost(opts ?? options);
+        }
+        const adapter = attachCompilerHostAdapter({
+            ts,
+            compilerHost: host,
+            resolver,
+            projectRoot,
+            createTypeInfoApiSession,
+            reportDiagnostic,
+        });
+        try {
+            return ts.createEmitAndSemanticDiagnosticsBuilderProgram(rootNames ?? fileNames, opts ?? options, host, oldProgram, configFileParsingDiagnostics, refs ?? projectReferences);
+        }
+        finally {
+            adapter.dispose();
+        }
+    };
+    const host = ts.createWatchCompilerHost(effectiveFileNames, options, sys, createProgram, reportDiagnostic, reportWatchStatus, projectReferences, watchOptions);
+    ts.createWatchProgram(host);
+}
+function createDiagnostic(ts, category, code, length, messageText) {
+    return { category, code, file: undefined, start: 0, length, messageText };
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@typed/virtual-modules-compiler",
+  "version": "1.0.0-beta.1",
+  "bin": {
+    "vmc": "./dist/cli.js"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "[ -d dist ] || rm -f tsconfig.tsbuildinfo; tsc",
+    "test": "vitest run --passWithNoTests"
+  },
+  "dependencies": {
+    "@typed/virtual-modules": "workspace:*",
+    "typescript": "catalog:"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  },
+  "files": [
+    "dist",
+    "src"
+  ]
+}

package/src/build.ts

@@ -0,0 +1,127 @@
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import type * as ts from "typescript";
+import type { TypeTargetSpec, VirtualModuleResolver } from "@typed/virtual-modules";
+import {
+  attachCompilerHostAdapter,
+  createTypeInfoApiSessionFactory,
+  ensureTypeTargetBootstrapFile,
+} from "@typed/virtual-modules";
+
+function inferProjectRoot(
+  sys: ts.System,
+  rootNames: readonly string[] | undefined,
+  fallback: string,
+): string {
+  if (rootNames && rootNames.length > 0) {
+    return dirname(rootNames[0]);
+  }
+  return fallback;
+}
+
+export interface BuildParams {
+  readonly ts: typeof import("typescript");
+  readonly buildCommand: ts.ParsedBuildCommand;
+  readonly resolver: VirtualModuleResolver;
+  readonly reportDiagnostic: ts.DiagnosticReporter;
+  readonly reportSolutionBuilderStatus?: ts.DiagnosticReporter;
+  readonly typeTargetSpecs?: readonly TypeTargetSpec[];
+}
+
+/**
+ * Run the compiler in build mode (tsc -b). Mirrors tsc --build.
+ */
+export function runBuild(params: BuildParams): number {
+  const { ts, buildCommand, resolver, reportDiagnostic, reportSolutionBuilderStatus, typeTargetSpecs } =
+    params;
+  const { projects, buildOptions } = buildCommand;
+
+  const sys = ts.sys;
+  if (!sys) {
+    reportDiagnostic(
+      createDiagnostic(ts, ts.DiagnosticCategory.Error, 0, 0, "ts.sys is not available."),
+    );
+    return 1;
+  }
+
+  const projectRoot = sys.getCurrentDirectory();
+
+  const createProgramForSession = (
+    rootNames: readonly string[],
+    opts: ts.CompilerOptions,
+  ): ts.Program => {
+    const h = ts.createCompilerHost(opts ?? {});
+    return ts.createProgram(rootNames, opts ?? {}, h);
+  };
+
+  const createProgram: ts.CreateProgram<ts.EmitAndSemanticDiagnosticsBuilderProgram> = (
+    rootNames,
+    opts,
+    host,
+    oldProgram,
+    configFileParsingDiagnostics,
+    refs,
+  ) => {
+    if (!host) {
+      host = ts.createCompilerHost(opts ?? {});
+    }
+    const root = inferProjectRoot(sys, rootNames, projectRoot);
+    let effectiveRootNames = rootNames ?? [];
+    if (typeTargetSpecs && typeTargetSpecs.length > 0) {
+      const bootstrapPath = ensureTypeTargetBootstrapFile(root, typeTargetSpecs, {
+        mkdirSync,
+        writeFile: (path, content) => sys.writeFile(path, content),
+      });
+      effectiveRootNames = effectiveRootNames.includes(bootstrapPath)
+        ? [...effectiveRootNames]
+        : [...effectiveRootNames, bootstrapPath];
+    }
+    const preliminaryProgram = createProgramForSession(effectiveRootNames, opts ?? {});
+    const createTypeInfoApiSession = createTypeInfoApiSessionFactory({
+      ts,
+      program: preliminaryProgram,
+      ...(typeTargetSpecs?.length ? { typeTargetSpecs } : {}),
+    });
+    const adapter = attachCompilerHostAdapter({
+      ts,
+      compilerHost: host,
+      resolver,
+      projectRoot: root,
+      createTypeInfoApiSession,
+      reportDiagnostic,
+    });
+    try {
+      return ts.createEmitAndSemanticDiagnosticsBuilderProgram(
+        effectiveRootNames,
+        opts ?? {},
+        host,
+        oldProgram,
+        configFileParsingDiagnostics,
+        refs,
+      );
+    } finally {
+      adapter.dispose();
+    }
+  };
+
+  const host = ts.createSolutionBuilderHost(
+    sys,
+    createProgram,
+    reportDiagnostic,
+    reportSolutionBuilderStatus,
+  );
+
+  const builder = ts.createSolutionBuilder(host, projects, buildOptions);
+  const exitCode = builder.build();
+  return exitCode === ts.ExitStatus.Success ? 0 : 1;
+}
+
+function createDiagnostic(
+  ts: typeof import("typescript"),
+  category: ts.DiagnosticCategory,
+  code: number,
+  length: number,
+  messageText: string,
+): ts.Diagnostic {
+  return { category, code, file: undefined, start: 0, length, messageText };
+}

package/src/cli.integration.test.ts

@@ -0,0 +1,207 @@
+/// <reference types="node" />
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, describe, expect, it } from "vitest";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const cliPath = join(__dirname, "..", "dist", "cli.js");
+
+const tempDirs: string[] = [];
+
+function createTempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "vmc-integration-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    const dir = tempDirs.pop();
+    if (dir) {
+      try {
+        rmSync(dir, { recursive: true, force: true });
+      } catch {
+        /* ignore */
+      }
+    }
+  }
+});
+
+function runVmc(
+  cwd: string,
+  args: string[] = [],
+): { exitCode: number; stdout: string; stderr: string } {
+  const result = spawnSync("node", [cliPath, ...args], {
+    cwd,
+    encoding: "utf8",
+    timeout: 15_000,
+  });
+  return {
+    exitCode: result.status ?? (result.signal ? 1 : 0),
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+  };
+}
+
+describe("vmc CLI integration", () => {
+  it("vmc init creates vmc.config.ts in project root", () => {
+    const dir = createTempDir();
+
+    const { exitCode, stdout, stderr } = runVmc(dir, ["init"]);
+    expect(stderr).toBe("");
+    expect(exitCode).toBe(0);
+    expect(stdout).toMatch(/Created .*vmc\.config\.ts/);
+
+    const configPath = join(dir, "vmc.config.ts");
+    const config = readFileSync(configPath, "utf8");
+    expect(config).toContain("export default");
+    expect(config).toContain("plugins:");
+    expect(config).toContain("shouldResolve");
+    expect(config).toContain("build");
+  });
+
+  it("vmc init refuses to overwrite existing config without --force", () => {
+    const dir = createTempDir();
+    const configPath = join(dir, "vmc.config.ts");
+    writeFileSync(configPath, "export default {};\n", "utf8");
+
+    const { exitCode, stdout, stderr } = runVmc(dir, ["init"]);
+    expect(exitCode).toBe(1);
+    expect(stdout).toMatch(/already exists/);
+    expect(stdout).toMatch(/--force/);
+
+    const config = readFileSync(configPath, "utf8");
+    expect(config).toBe("export default {};\n");
+  });
+
+  it("vmc init --force overwrites existing config", () => {
+    const dir = createTempDir();
+    const configPath = join(dir, "vmc.config.ts");
+    writeFileSync(configPath, "export default {};\n", "utf8");
+
+    const { exitCode, stdout } = runVmc(dir, ["init", "--force"]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toMatch(/Created/);
+
+    const config = readFileSync(configPath, "utf8");
+    expect(config).toContain("plugins:");
+    expect(config).not.toBe("export default {};\n");
+  });
+
+  it("compiles project with virtual modules via vmc.config.ts", () => {
+    const dir = createTempDir();
+    const srcDir = join(dir, "src");
+    mkdirSync(srcDir, { recursive: true });
+
+    writeFileSync(
+      join(dir, "tsconfig.json"),
+      JSON.stringify({
+        compilerOptions: {
+          strict: true,
+          target: "ESNext",
+          module: "ESNext",
+          moduleResolution: "Bundler",
+          noEmit: true,
+          skipLibCheck: true,
+        },
+        include: ["src"],
+      }),
+      "utf8",
+    );
+    writeFileSync(
+      join(dir, "vmc.config.ts"),
+      `export default {
+  plugins: [{
+    name: "virtual",
+    shouldResolve: (id) => id === "virtual:foo",
+    build: () => "export interface Foo { n: number }",
+  }],
+};
+`,
+      "utf8",
+    );
+    writeFileSync(
+      join(srcDir, "entry.ts"),
+      'import type { Foo } from "virtual:foo";\nexport const value: Foo = { n: 1 };\n',
+      "utf8",
+    );
+
+    const { exitCode, stderr } = runVmc(dir, ["--noEmit"]);
+    expect(stderr).toBe("");
+    expect(exitCode).toBe(0);
+  });
+
+  it("reports diagnostics when virtual module type is wrong", () => {
+    const dir = createTempDir();
+    const srcDir = join(dir, "src");
+    mkdirSync(srcDir, { recursive: true });
+
+    writeFileSync(
+      join(dir, "tsconfig.json"),
+      JSON.stringify({
+        compilerOptions: {
+          strict: true,
+          target: "ESNext",
+          module: "ESNext",
+          moduleResolution: "Bundler",
+          noEmit: true,
+          skipLibCheck: true,
+        },
+        include: ["src"],
+      }),
+      "utf8",
+    );
+    writeFileSync(
+      join(dir, "vmc.config.ts"),
+      `export default {
+  plugins: [{
+    name: "virtual",
+    shouldResolve: (id) => id === "virtual:foo",
+    build: () => "export interface Foo { n: number }",
+  }],
+};
+`,
+      "utf8",
+    );
+    writeFileSync(
+      join(srcDir, "entry.ts"),
+      'import type { Foo } from "virtual:foo";\nexport const value: Foo = { n: "wrong" };\n',
+      "utf8",
+    );
+
+    const { exitCode, stdout, stderr } = runVmc(dir, ["--noEmit"]);
+    expect(exitCode).toBe(1);
+    const output = stdout + stderr;
+    expect(output).toMatch(/string|number/);
+  });
+
+  it("compiles without vmc.config when no virtual modules", () => {
+    const dir = createTempDir();
+    const srcDir = join(dir, "src");
+    mkdirSync(srcDir, { recursive: true });
+
+    writeFileSync(
+      join(dir, "tsconfig.json"),
+      JSON.stringify({
+        compilerOptions: {
+          strict: true,
+          target: "ESNext",
+          module: "ESNext",
+          moduleResolution: "Bundler",
+          noEmit: true,
+          skipLibCheck: true,
+        },
+        include: ["src"],
+      }),
+      "utf8",
+    );
+    writeFileSync(join(srcDir, "entry.ts"), "export const x = 1;\n", "utf8");
+
+    const { exitCode, stderr } = runVmc(dir, ["--noEmit"]);
+    expect(stderr).toBe("");
+    expect(exitCode).toBe(0);
+  });
+});

package/src/cli.ts

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+import ts from "typescript";
+import { resolveCommandLine } from "./commandLine.js";
+import { loadResolver } from "./resolverLoader.js";
+import { compile } from "./compile.js";
+import { runWatch } from "./watch.js";
+import { runBuild } from "./build.js";
+import { runInit } from "./init.js";
+
+const args = process.argv.slice(2);
+const sys = ts.sys;
+
+if (!sys) {
+  console.error("vmc: ts.sys is not available.");
+  process.exit(1);
+}
+
+const reportDiagnostic: ts.DiagnosticReporter = (diagnostic) => {
+  const message = ts.formatDiagnostic(diagnostic, {
+    getCanonicalFileName: (f) => f,
+    // oxlint-disable-next-line typescript/unbound-method
+    getCurrentDirectory: sys.getCurrentDirectory,
+    getNewLine: () => sys.newLine,
+  });
+  if (diagnostic.category === ts.DiagnosticCategory.Error) {
+    sys.write(message);
+  } else {
+    sys.write(message);
+  }
+};
+
+function main(): number {
+  if (args[0] === "init") {
+    const force = args.includes("--force");
+    const result = runInit({
+      projectRoot: sys.getCurrentDirectory(),
+      force,
+    });
+    if (result.ok) {
+      sys.write(result.message + sys.newLine);
+      return 0;
+    }
+    sys.write(result.message + sys.newLine);
+    return 1;
+  }
+
+  const buildIndex = args.findIndex((a) => a === "--build" || a === "-b");
+  const watchIndex = args.findIndex((a) => a === "--watch" || a === "-w");
+
+  if (buildIndex >= 0) {
+    const buildArgs = args.filter((_, i) => i !== buildIndex);
+    const parsed = ts.parseBuildCommand(buildArgs);
+    for (const d of parsed.errors) {
+      reportDiagnostic(d);
+    }
+    if (parsed.errors.length > 0) {
+      return 1;
+    }
+  const projectRoot = sys.getCurrentDirectory();
+  const { resolver, typeTargetSpecs } = loadResolver(projectRoot);
+  return runBuild({
+    ts,
+    buildCommand: parsed,
+    resolver,
+    typeTargetSpecs,
+      reportDiagnostic,
+      reportSolutionBuilderStatus: reportDiagnostic,
+    });
+  }
+
+  const watchArgs = watchIndex >= 0 ? args.filter((_, i) => i !== watchIndex) : args;
+  // oxlint-disable-next-line typescript/unbound-method
+  let commandLine = ts.parseCommandLine(watchArgs, sys.readFile);
+  commandLine = resolveCommandLine(ts, commandLine, sys);
+
+  for (const d of commandLine.errors) {
+    reportDiagnostic(d);
+  }
+  if (commandLine.errors.length > 0) {
+    return 1;
+  }
+
+  const projectRoot = sys.getCurrentDirectory();
+  const { resolver, typeTargetSpecs } = loadResolver(projectRoot);
+
+  if (watchIndex >= 0) {
+    runWatch({
+      ts,
+      commandLine,
+      resolver,
+      typeTargetSpecs,
+      reportDiagnostic,
+      reportWatchStatus: (diag, newLine, _opts, _errorCount) => {
+        sys.write(
+          ts.formatDiagnostic(diag, {
+            getCanonicalFileName: (f) => f,
+            // oxlint-disable-next-line typescript/unbound-method
+            getCurrentDirectory: sys.getCurrentDirectory,
+            getNewLine: () => newLine,
+          }),
+        );
+      },
+    });
+    return 0;
+  }
+
+  return compile({
+    ts,
+    commandLine,
+    resolver,
+    reportDiagnostic,
+    typeTargetSpecs,
+  });
+}
+
+process.exit(main());

package/src/commandLine.ts

@@ -0,0 +1,54 @@
+import type * as ts from "typescript";
+
+/**
+ * Resolve the parsed command line. When fileNames is empty (e.g. "tsc" with no args),
+ * find tsconfig.json and use getParsedCommandLineOfConfigFile to populate fileNames.
+ * This mirrors tsc behavior.
+ */
+export function resolveCommandLine(
+  ts: typeof import("typescript"),
+  commandLine: ts.ParsedCommandLine,
+  sys: ts.System,
+): ts.ParsedCommandLine {
+  if (commandLine.fileNames.length > 0) {
+    return commandLine;
+  }
+
+  const project = (commandLine.options as { project?: string }).project;
+  const cwd = sys.getCurrentDirectory();
+  let configPath: string | undefined;
+  if (project) {
+    configPath = sys.fileExists(project)
+      ? project
+      : ts.findConfigFile(project, (p) => sys.fileExists(p));
+  } else {
+    configPath = ts.findConfigFile(cwd, (p) => sys.fileExists(p));
+  }
+
+  if (!configPath) {
+    return commandLine;
+  }
+
+  const configHost: ts.ParseConfigFileHost = {
+    getCurrentDirectory: () => sys.getCurrentDirectory(),
+    useCaseSensitiveFileNames: sys.useCaseSensitiveFileNames,
+    readDirectory: sys.readDirectory,
+    fileExists: sys.fileExists,
+    readFile: (p) => sys.readFile(p),
+    onUnRecoverableConfigFileDiagnostic: (_d) => {
+      // Will be reported by caller
+    },
+  };
+
+  const resolved = ts.getParsedCommandLineOfConfigFile(configPath, commandLine.options, configHost);
+
+  if (!resolved) {
+    return commandLine;
+  }
+
+  return {
+    ...commandLine,
+    ...resolved,
+    options: { ...commandLine.options, ...resolved.options },
+  };
+}