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

package/src/compile.ts

@@ -0,0 +1,150 @@
+import { mkdirSync } from "node:fs";
+import type * as ts from "typescript";
+import type { TypeTargetSpec, VirtualModuleResolver } from "@typed/virtual-modules";
+import {
+  attachCompilerHostAdapter,
+  createTypeInfoApiSessionFactory,
+  ensureTypeTargetBootstrapFile,
+} from "@typed/virtual-modules";
+
+export interface CompileParams {
+  readonly ts: typeof import("typescript");
+  readonly commandLine: ts.ParsedCommandLine;
+  readonly resolver: VirtualModuleResolver;
+  readonly reportDiagnostic: ts.DiagnosticReporter;
+  /** Type target specs for structural assignability in TypeInfo API. From vmc.config when using loadResolver. */
+  readonly typeTargetSpecs?: readonly TypeTargetSpec[];
+}
+
+/**
+ * Perform a single compile pass using the adapted compiler host.
+ * Mirrors tsc behavior: create program, emit, report diagnostics, return exit code.
+ */
+export function compile(params: CompileParams): number {
+  const { ts, commandLine, resolver, reportDiagnostic, typeTargetSpecs } = params;
+  const { options, fileNames, projectReferences } = commandLine;
+  const configFileParsingDiagnostics = (
+    commandLine as { configFileParsingDiagnostics?: readonly ts.Diagnostic[] }
+  ).configFileParsingDiagnostics;
+
+  const configParseDiags =
+    (
+      ts as {
+        getConfigFileParsingDiagnostics?: (p: ts.ParsedCommandLine) => readonly ts.Diagnostic[];
+      }
+    ).getConfigFileParsingDiagnostics?.(commandLine) ?? commandLine.errors;
+  const allConfigErrors = [...(configFileParsingDiagnostics ?? []), ...configParseDiags];
+  for (const d of allConfigErrors) {
+    reportDiagnostic(d);
+  }
+  if (allConfigErrors.length > 0) {
+    return 1;
+  }
+
+  if (fileNames.length === 0) {
+    reportDiagnostic(
+      createDiagnostic(
+        ts,
+        ts.DiagnosticCategory.Message,
+        0,
+        0,
+        "No inputs were found in config file.",
+      ),
+    );
+    return 0;
+  }
+
+  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();
+
+  let effectiveRootNames = fileNames;
+  if (typeTargetSpecs && typeTargetSpecs.length > 0) {
+    const bootstrapPath = ensureTypeTargetBootstrapFile(projectRoot, typeTargetSpecs, {
+      mkdirSync,
+      writeFile: (path, content) => sys.writeFile(path, content),
+    });
+    effectiveRootNames = fileNames.includes(bootstrapPath)
+      ? fileNames
+      : [...fileNames, bootstrapPath];
+  }
+
+  const host = ts.createCompilerHost(options);
+
+  // Preliminary program for TypeInfo API (plugins that use api.file()/api.directory() need it).
+  const preliminaryProgram = ts.createProgram({
+    rootNames: effectiveRootNames,
+    options,
+    host,
+    projectReferences,
+    configFileParsingDiagnostics: allConfigErrors,
+  });
+  const createTypeInfoApiSession = createTypeInfoApiSessionFactory({
+    ts,
+    program: preliminaryProgram,
+    ...(typeTargetSpecs?.length ? { typeTargetSpecs } : {}),
+  });
+
+  const adapter = attachCompilerHostAdapter({
+    ts,
+    compilerHost: host,
+    resolver,
+    projectRoot,
+    createTypeInfoApiSession,
+    reportDiagnostic,
+  });
+
+  let exitCode = 0;
+  try {
+    const program = ts.createProgram({
+      rootNames: effectiveRootNames,
+      options,
+      host,
+      projectReferences,
+      configFileParsingDiagnostics: allConfigErrors,
+    });
+
+    const preEmit = ts.getPreEmitDiagnostics(program);
+    // oxlint-disable-next-line typescript/unbound-method
+    const emitResult = program.emit(undefined, sys.writeFile);
+    const allDiagnostics = [...preEmit, ...emitResult.diagnostics];
+
+    for (const d of allDiagnostics) {
+      reportDiagnostic(d);
+    }
+
+    if (
+      emitResult.emitSkipped ||
+      allDiagnostics.some((d) => d.category === ts.DiagnosticCategory.Error)
+    ) {
+      exitCode = 1;
+    }
+  } finally {
+    adapter.dispose();
+  }
+
+  return exitCode;
+}
+
+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/index.ts

@@ -0,0 +1,9 @@
+export {
+  loadResolver,
+  type LoadResolverResult,
+  type VmcConfig,
+} from "./resolverLoader.js";
+export { resolveCommandLine } from "./commandLine.js";
+export { compile } from "./compile.js";
+export { runWatch } from "./watch.js";
+export { runBuild } from "./build.js";

package/src/init.ts

@@ -0,0 +1,50 @@
+import { existsSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+const VMC_CONFIG_FILENAME = "vmc.config.ts";
+
+const INITIAL_VMC_CONFIG = `export default {
+  plugins: [
+    {
+      name: "example",
+      shouldResolve: (id) => id.startsWith("virtual:"),
+      build: (id) => {
+        // Return generated TypeScript source for the virtual module
+        const name = id.replace("virtual:", "");
+        return \`export type \${name} = { value: string };\`;
+      },
+    },
+  ],
+};
+`;
+
+export interface InitOptions {
+  readonly projectRoot: string;
+  readonly force?: boolean;
+}
+
+export interface InitResult {
+  readonly ok: boolean;
+  readonly path: string;
+  readonly message: string;
+}
+
+export function runInit(options: InitOptions): InitResult {
+  const { projectRoot, force = false } = options;
+  const configPath = join(projectRoot, VMC_CONFIG_FILENAME);
+
+  if (existsSync(configPath) && !force) {
+    return {
+      ok: false,
+      path: configPath,
+      message: `vmc.config.ts already exists at ${configPath}. Use --force to overwrite.`,
+    };
+  }
+
+  writeFileSync(configPath, INITIAL_VMC_CONFIG.trim() + "\n", "utf8");
+  return {
+    ok: true,
+    path: configPath,
+    message: `Created ${configPath}`,
+  };
+}

package/src/resolverLoader.ts

@@ -0,0 +1,44 @@
+import ts from "typescript";
+import type {
+  TypeTargetSpec,
+  VirtualModuleResolver,
+  VmcPluginEntry,
+} from "@typed/virtual-modules";
+import { loadResolverFromVmcConfig, PluginManager } from "@typed/virtual-modules";
+
+export interface VmcConfig {
+  readonly resolver?: VirtualModuleResolver;
+  readonly plugins?: readonly VmcPluginEntry[];
+}
+
+export interface LoadResolverResult {
+  readonly resolver: VirtualModuleResolver;
+  readonly typeTargetSpecs?: readonly TypeTargetSpec[];
+}
+
+/**
+ * Load the resolver from vmc.config.* in projectRoot, or return an empty PluginManager.
+ * Also returns typeTargetSpecs when configured for structural assignability in TypeInfo API.
+ */
+export function loadResolver(projectRoot: string): LoadResolverResult {
+  const loaded = loadResolverFromVmcConfig({ projectRoot, ts });
+  if (loaded.status === "not-found") {
+    return { resolver: new PluginManager() };
+  }
+  if (loaded.status === "error") {
+    console.error(`[vmc] ${loaded.message}`);
+    process.exit(1);
+  }
+
+  if (loaded.pluginLoadErrors.length > 0) {
+    for (const error of loaded.pluginLoadErrors) {
+      console.error(`[vmc] Failed to load plugin "${error.specifier}": ${error.message}`);
+    }
+    process.exit(1);
+  }
+
+  return {
+    resolver: loaded.resolver ?? new PluginManager(),
+    ...(loaded.typeTargetSpecs ? { typeTargetSpecs: loaded.typeTargetSpecs } : {}),
+  };
+}

package/src/watch.ts

@@ -0,0 +1,116 @@
+import { mkdirSync } from "node:fs";
+import type * as ts from "typescript";
+import type { TypeTargetSpec, VirtualModuleResolver } from "@typed/virtual-modules";
+import {
+  attachCompilerHostAdapter,
+  createTypeInfoApiSessionFactory,
+  ensureTypeTargetBootstrapFile,
+} from "@typed/virtual-modules";
+
+export interface WatchParams {
+  readonly ts: typeof import("typescript");
+  readonly commandLine: ts.ParsedCommandLine;
+  readonly resolver: VirtualModuleResolver;
+  readonly reportDiagnostic: ts.DiagnosticReporter;
+  readonly reportWatchStatus?: ts.WatchStatusReporter;
+  readonly typeTargetSpecs?: readonly TypeTargetSpec[];
+}
+
+/**
+ * Run the compiler in watch mode. Mirrors tsc --watch.
+ */
+export function runWatch(params: WatchParams): void {
+  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: ts.CreateProgram<ts.EmitAndSemanticDiagnosticsBuilderProgram> = (
+    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: typeof import("typescript"),
+  category: ts.DiagnosticCategory,
+  code: number,
+  length: number,
+  messageText: string,
+): ts.Diagnostic {
+  return { category, code, file: undefined, start: 0, length, messageText };
+}