@typed/virtual-modules 1.0.0-beta.1

package/src/LanguageServiceAdapter.ts

@@ -0,0 +1,631 @@
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type * as ts from "typescript";
+import {
+  type LanguageServiceAdapterOptions,
+  type LanguageServiceWatchHost,
+  type VirtualModuleAdapterHandle,
+} from "./types.js";
+import { unlinkSync } from "node:fs";
+import {
+  materializeVirtualFile,
+  rewriteSourceForPreviewLocation,
+} from "./internal/materializeVirtualFile.js";
+import {
+  createVirtualRecordStore,
+  toResolvedModule,
+  type MutableVirtualRecord,
+  type ResolveRecordResult,
+} from "./internal/VirtualRecordStore.js";
+import {
+  VIRTUAL_MODULE_URI_SCHEME,
+  VIRTUAL_NODE_MODULES_RELATIVE,
+} from "./internal/path.js";
+import { Mutable } from "effect/Types";
+
+/** Prefix VSCode uses when sending non-file URIs to tsserver (query params are dropped). */
+const IN_MEMORY_RESOURCE_PREFIX = "^";
+
+/** Schemes used by VSCode extension for virtual module preview docs. */
+const PREVIEW_SCHEMES = ["virtual-module", VIRTUAL_MODULE_URI_SCHEME] as const;
+
+/**
+ * Parse a fileName that may be:
+ * 1) Full URI: virtual-module:///module.ts?id=x&importer=y (query may be dropped by VSCode)
+ * 2) tsserver path: ^/virtual-module/ts-nul-authority/path/to/__virtual_plugin_hash.ts
+ */
+function parsePreviewUri(
+  fileName: string,
+): { id: string; importer: string } | { virtualPath: string } | undefined {
+  const pathBased = tryParsePathBasedFromTsServer(fileName);
+  if (pathBased) return pathBased;
+
+  if (!fileName.includes("://")) return undefined;
+  try {
+    const url = new URL(fileName);
+    if (
+      !PREVIEW_SCHEMES.includes(url.protocol.replace(":", "") as (typeof PREVIEW_SCHEMES)[number])
+    )
+      return undefined;
+    const id = url.searchParams.get("id");
+    const importerRaw = url.searchParams.get("importer");
+    if (!id || !importerRaw) return undefined;
+    const importer = importerRaw.startsWith("file:")
+      ? (() => {
+          try {
+            return fileURLToPath(importerRaw);
+          } catch {
+            return importerRaw;
+          }
+        })()
+      : importerRaw;
+    return { id, importer };
+  } catch {
+    return undefined;
+  }
+}
+
+function tryParsePathBasedFromTsServer(fileName: string): { virtualPath: string } | undefined {
+  if (!fileName.startsWith(IN_MEMORY_RESOURCE_PREFIX + "/")) return undefined;
+  const rest = fileName.slice(IN_MEMORY_RESOURCE_PREFIX.length);
+  const parts = rest.split("/");
+  if (parts.length < 4) return undefined;
+  const [scheme] = [parts[1], parts[2]];
+  if (!PREVIEW_SCHEMES.includes(scheme as (typeof PREVIEW_SCHEMES)[number])) return undefined;
+  const path = "/" + parts.slice(3).join("/");
+  if (!path.includes("__virtual_")) return undefined;
+  return { virtualPath: path };
+}
+
+interface ProjectServiceLike {
+  getOrCreateOpenScriptInfo?(
+    fileName: string,
+    fileContent: string | undefined,
+    scriptKind: ts.ScriptKind,
+    hasMixedContent: boolean,
+    projectRootPath: string | undefined,
+  ): unknown;
+}
+
+const ADAPTER_DIAGNOSTIC_CODE = 99001;
+
+const toTsDiagnostic = (
+  tsMod: typeof import("typescript"),
+  message: string,
+  file?: ts.SourceFile,
+): ts.Diagnostic => ({
+  category: tsMod.DiagnosticCategory.Error,
+  code: ADAPTER_DIAGNOSTIC_CODE,
+  file,
+  start: 0,
+  length: 0,
+  messageText: message,
+});
+
+export const attachLanguageServiceAdapter = (
+  options: LanguageServiceAdapterOptions,
+): VirtualModuleAdapterHandle => {
+  if (typeof options.projectRoot !== "string" || options.projectRoot.trim() === "") {
+    throw new Error("projectRoot must be a non-empty string");
+  }
+
+  const host = options.languageServiceHost as ts.LanguageServiceHost & Record<string, unknown>;
+  const watchHost = (options.watchHost ??
+    (options.languageServiceHost as unknown as LanguageServiceWatchHost)) as
+    | LanguageServiceWatchHost
+    | undefined;
+
+  const diagnosticsByFile = new Map<string, ts.Diagnostic[]>();
+  let epoch = 0;
+  let inResolution = false;
+  let inResolveRecord = false;
+  let pendingRetry = false;
+
+  const originalGetScriptFileNames = host.getScriptFileNames?.bind(host);
+  const originalResolveModuleNameLiterals = host.resolveModuleNameLiterals?.bind(host);
+  const originalResolveModuleNames = host.resolveModuleNames?.bind(host);
+  const originalGetScriptSnapshot = host.getScriptSnapshot?.bind(host);
+  const originalGetScriptVersion = host.getScriptVersion?.bind(host);
+  const originalGetProjectVersion = host.getProjectVersion?.bind(host);
+  const originalFileExists = host.fileExists?.bind(host);
+  const originalReadFile = host.readFile?.bind(host);
+  const originalGetSemanticDiagnostics = options.languageService.getSemanticDiagnostics.bind(
+    options.languageService,
+  );
+  const originalGetSyntacticDiagnostics = options.languageService.getSyntacticDiagnostics.bind(
+    options.languageService,
+  );
+
+  const addDiagnosticForFile = (filePath: string, message: string): void => {
+    const diagnostic = toTsDiagnostic(options.ts, message);
+    const diagnostics = diagnosticsByFile.get(filePath) ?? [];
+    diagnostics.push(diagnostic);
+    diagnosticsByFile.set(filePath, diagnostics);
+  };
+
+  const clearDiagnosticsForFile = (filePath: string): void => {
+    diagnosticsByFile.delete(filePath);
+  };
+
+  const store = createVirtualRecordStore({
+    projectRoot: options.projectRoot,
+    resolver: options.resolver,
+    createTypeInfoApiSession: options.createTypeInfoApiSession,
+    debounceMs: options.debounceMs,
+    watchHost,
+    shouldEvictRecord: (record) => {
+      const currentFiles = new Set(originalGetScriptFileNames ? originalGetScriptFileNames() : []);
+      return !currentFiles.has(record.importer);
+    },
+    onFlushStale: () => {
+      epoch += 1;
+    },
+    onBeforeResolve: () => {
+      inResolveRecord = true;
+    },
+    onAfterResolve: () => {
+      inResolveRecord = false;
+    },
+    onRecordResolved: (record) => {
+      clearDiagnosticsForFile(record.importer);
+    },
+    onEvictRecord: (record) => {
+      clearDiagnosticsForFile(record.importer);
+      if (record.virtualFileName.includes(VIRTUAL_NODE_MODULES_RELATIVE)) {
+        try {
+          unlinkSync(record.virtualFileName);
+        } catch {
+          /* ignore if already deleted or missing */
+        }
+      }
+    },
+  });
+
+  const { recordsByVirtualFile } = store;
+
+  const getOrBuildRecord = (id: string, importer: string): ResolveRecordResult => {
+    store.evictStaleImporters();
+
+    if (inResolveRecord) {
+      return {
+        status: "error",
+        diagnostic: {
+          code: "re-entrant-resolution",
+          pluginName: "",
+          message:
+            "Re-entrant resolution not allowed; plugins must not trigger module resolution during build()",
+        },
+      };
+    }
+
+    return store.getOrBuildRecord(id, importer);
+  };
+
+  const rebuildRecordIfNeeded = (record: MutableVirtualRecord): MutableVirtualRecord => {
+    if (!record.stale) {
+      return record;
+    }
+
+    const rebuilt = store.resolveRecord(record.id, record.importer, record);
+    if (rebuilt.status === "resolved") {
+      clearDiagnosticsForFile(record.importer);
+      return rebuilt.record;
+    }
+
+    if (rebuilt.status === "error") {
+      const diagnostic = toTsDiagnostic(
+        options.ts,
+        `Virtual module rebuild failed: ${rebuilt.diagnostic.message}`,
+      );
+      const diagnostics = diagnosticsByFile.get(record.importer) ?? [];
+      diagnostics.push(diagnostic);
+      diagnosticsByFile.set(record.importer, diagnostics);
+    }
+    return record;
+  };
+
+  const fallbackResolveModule = (
+    moduleName: string,
+    containingFile: string,
+    compilerOptions: ts.CompilerOptions | undefined,
+  ): ts.ResolvedModuleFull | undefined => {
+    const result = options.ts.resolveModuleName(moduleName, containingFile, compilerOptions ?? {}, {
+      fileExists: (path) => host.fileExists?.(path) ?? false,
+      readFile: (path) => host.readFile?.(path),
+      directoryExists: (path) =>
+        host.directoryExists?.(path) ?? options.ts.sys.directoryExists(path),
+      getCurrentDirectory: () =>
+        host.getCurrentDirectory?.() ?? options.ts.sys.getCurrentDirectory(),
+      getDirectories: (path) => {
+        const fromHost = host.getDirectories?.(path);
+        if (fromHost !== undefined) return [...fromHost];
+        const fromSys = options.ts.sys.getDirectories?.(path);
+        return fromSys !== undefined ? [...fromSys] : [];
+      },
+      realpath: (path) => host.realpath?.(path) ?? options.ts.sys.realpath?.(path) ?? path,
+      useCaseSensitiveFileNames:
+        host.useCaseSensitiveFileNames?.() ?? options.ts.sys.useCaseSensitiveFileNames,
+    });
+
+    return result.resolvedModule as ts.ResolvedModuleFull | undefined;
+  };
+
+  host.resolveModuleNames = (
+    moduleNames: string[],
+    containingFile: string,
+    reusedNames: string[] | undefined,
+    redirectedReference: ts.ResolvedProjectReference | undefined,
+    compilerOptions: ts.CompilerOptions,
+    containingSourceFile?: ts.SourceFile,
+  ): (ts.ResolvedModule | undefined)[] => {
+    if (inResolution) {
+      if (inResolveRecord) {
+        const diagnostic = toTsDiagnostic(
+          options.ts,
+          "Re-entrant resolution not allowed; plugins must not trigger module resolution during build()",
+        );
+        const diagnostics = diagnosticsByFile.get(containingFile) ?? [];
+        diagnostics.push(diagnostic);
+        diagnosticsByFile.set(containingFile, diagnostics);
+      }
+      return moduleNames.map(() => undefined);
+    }
+
+    inResolution = true;
+    try {
+      const parsed = parsePreviewUri(containingFile);
+      let effectiveContainingFile = containingFile;
+      let importerForVirtual = containingFile;
+      if (parsed) {
+        if ("virtualPath" in parsed) {
+          const r = recordsByVirtualFile.get(parsed.virtualPath);
+          if (r) {
+            effectiveContainingFile = r.virtualFileName;
+            importerForVirtual = r.importer;
+          }
+        } else {
+          const r = getOrBuildRecord(parsed.id, parsed.importer);
+          if (r.status === "resolved") {
+            effectiveContainingFile = r.record.virtualFileName;
+            importerForVirtual = r.record.importer;
+          }
+        }
+      }
+
+      const fallback = originalResolveModuleNames
+        ? originalResolveModuleNames(
+            moduleNames,
+            effectiveContainingFile,
+            reusedNames,
+            redirectedReference,
+            compilerOptions,
+            containingSourceFile,
+          )
+        : moduleNames.map((moduleName) =>
+            fallbackResolveModule(moduleName, effectiveContainingFile, compilerOptions),
+          );
+
+      let hadVirtualError = false;
+      let hadUnresolvedVirtual = false;
+      const results = moduleNames.map((moduleName, index) => {
+        const resolved = getOrBuildRecord(moduleName, importerForVirtual);
+        if (resolved.status === "resolved") {
+          pendingRetry = false;
+          return toResolvedModule(options.ts, resolved.record.virtualFileName);
+        }
+
+        if (resolved.status === "error") {
+          hadVirtualError = true;
+          addDiagnosticForFile(containingFile, resolved.diagnostic.message);
+          if (resolved.diagnostic.code === "re-entrant-resolution") {
+            return undefined;
+          }
+        }
+
+        if (resolved.status === "unresolved" && moduleName.includes(":")) {
+          hadUnresolvedVirtual = true;
+        }
+
+        return fallback[index];
+      });
+
+      if ((hadVirtualError || hadUnresolvedVirtual) && !pendingRetry) {
+        pendingRetry = true;
+        epoch += 1;
+      }
+
+      return results;
+    } finally {
+      inResolution = false;
+    }
+  };
+
+  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[] => {
+    if (inResolution) {
+      if (inResolveRecord) {
+        const diagnostic = toTsDiagnostic(
+          options.ts,
+          "Re-entrant resolution not allowed; plugins must not trigger module resolution during build()",
+        );
+        const diagnostics = diagnosticsByFile.get(containingFile) ?? [];
+        diagnostics.push(diagnostic);
+        diagnosticsByFile.set(containingFile, diagnostics);
+      }
+      return moduleLiterals.map(() => ({ resolvedModule: undefined }));
+    }
+
+    inResolution = true;
+    try {
+      const parsed = parsePreviewUri(containingFile);
+      let effectiveContainingFile = containingFile;
+      let importerForVirtual = containingFile;
+      if (parsed) {
+        if ("virtualPath" in parsed) {
+          const r = recordsByVirtualFile.get(parsed.virtualPath);
+          if (r) {
+            effectiveContainingFile = r.virtualFileName;
+            importerForVirtual = r.importer;
+          }
+        } else {
+          const r = getOrBuildRecord(parsed.id, parsed.importer);
+          if (r.status === "resolved") {
+            effectiveContainingFile = r.record.virtualFileName;
+            importerForVirtual = r.record.importer;
+          }
+        }
+      }
+
+      const fallback: readonly ts.ResolvedModuleWithFailedLookupLocations[] =
+        originalResolveModuleNameLiterals
+          ? (originalResolveModuleNameLiterals(
+              moduleLiterals as unknown as readonly ts.StringLiteralLike[],
+              effectiveContainingFile,
+              redirectedReference,
+              compilerOptions,
+              containingSourceFile!,
+              reusedNames as readonly ts.StringLiteralLike[] | undefined,
+            ) as readonly ts.ResolvedModuleWithFailedLookupLocations[])
+          : moduleLiterals.map((moduleLiteral) => ({
+              resolvedModule: fallbackResolveModule(
+                moduleLiteral.text,
+                effectiveContainingFile,
+                compilerOptions,
+              ),
+            }));
+
+      let hadVirtualError = false;
+      let hadUnresolvedVirtual = false;
+      const results = moduleLiterals.map((moduleLiteral, index) => {
+        const resolved = getOrBuildRecord(moduleLiteral.text, importerForVirtual);
+        if (moduleLiteral.text.includes(":")) {
+          try {
+            require("node:fs").appendFileSync(
+              "/tmp/vm-ts-plugin-debug.log",
+              JSON.stringify({
+                tag: "LS:resolveLiterals",
+                id: moduleLiteral.text,
+                status: resolved.status,
+                err: resolved.status === "error" ? (resolved as { diagnostic?: { message?: string } }).diagnostic?.message : undefined,
+                t: Date.now(),
+              }) + "\n",
+              { flag: "a" },
+            );
+          } catch {
+            /* noop */
+          }
+        }
+        if (resolved.status === "resolved") {
+          pendingRetry = false;
+          return {
+            resolvedModule: toResolvedModule(options.ts, resolved.record.virtualFileName),
+          };
+        }
+
+        if (resolved.status === "error") {
+          hadVirtualError = true;
+          addDiagnosticForFile(containingFile, resolved.diagnostic.message);
+          if (resolved.diagnostic.code === "re-entrant-resolution") {
+            return fallback[index];
+          }
+        }
+
+        if (resolved.status === "unresolved" && moduleLiteral.text.includes(":")) {
+          hadUnresolvedVirtual = true;
+        }
+
+        return fallback[index];
+      });
+
+      if ((hadVirtualError || hadUnresolvedVirtual) && !pendingRetry) {
+        pendingRetry = true;
+        epoch += 1;
+      }
+
+      return results;
+    } finally {
+      inResolution = false;
+    }
+  };
+  host.resolveModuleNameLiterals = assignResolveModuleNameLiterals;
+
+  const projectService = (host as { projectService?: ProjectServiceLike }).projectService;
+
+  host.getScriptSnapshot = (fileName: string): ts.IScriptSnapshot | undefined => {
+    let record = recordsByVirtualFile.get(fileName);
+    if (!record) {
+      const parsed = parsePreviewUri(fileName);
+      if (parsed) {
+        if ("virtualPath" in parsed) {
+          record = recordsByVirtualFile.get(parsed.virtualPath) ?? undefined;
+        } else {
+          const resolved = getOrBuildRecord(parsed.id, parsed.importer);
+          if (resolved.status === "resolved") record = resolved.record;
+        }
+      }
+    }
+    if (!record) {
+      return originalGetScriptSnapshot?.(fileName);
+    }
+
+    const freshRecord = rebuildRecordIfNeeded(record);
+
+    let sourceToServe = freshRecord.sourceText;
+    const isNodeModulesPath = fileName.includes(VIRTUAL_NODE_MODULES_RELATIVE);
+    if (isNodeModulesPath) {
+      sourceToServe = rewriteSourceForPreviewLocation(
+        freshRecord.sourceText,
+        freshRecord.importer,
+        fileName,
+      );
+      materializeVirtualFile(fileName, freshRecord.importer, freshRecord.sourceText);
+    }
+
+    // In tsserver, setDocument(key, path, sourceFile) requires a ScriptInfo for path (Debug.checkDefined(getScriptInfoForPath(path))).
+    // If we never register the virtual file, createProgram → acquireOrUpdateDocument → setDocument throws "Debug Failure".
+    // So when projectService exists (tsserver), always register the virtual file so setDocument can find it.
+    if (projectService?.getOrCreateOpenScriptInfo) {
+      projectService.getOrCreateOpenScriptInfo(
+        fileName,
+        sourceToServe,
+        options.ts.ScriptKind.TS,
+        false,
+        options.projectRoot,
+      );
+    }
+
+    return options.ts.ScriptSnapshot.fromString(sourceToServe);
+  };
+
+  if (originalGetScriptVersion) {
+    host.getScriptVersion = (fileName: string): string => {
+      let record = recordsByVirtualFile.get(fileName);
+      if (!record) {
+        const parsed = parsePreviewUri(fileName);
+        if (parsed) {
+          if ("virtualPath" in parsed) {
+            record = recordsByVirtualFile.get(parsed.virtualPath) ?? undefined;
+          } else {
+            const resolved = getOrBuildRecord(parsed.id, parsed.importer);
+            if (resolved.status === "resolved") record = resolved.record;
+          }
+        }
+      }
+      if (!record) return originalGetScriptVersion(fileName);
+      return String(record.version);
+    };
+  }
+
+  if (originalGetProjectVersion) {
+    host.getProjectVersion = (): string => `${originalGetProjectVersion()}:vm:${epoch}`;
+  }
+
+  if (originalGetScriptFileNames) {
+    host.getScriptFileNames = (): string[] => {
+      const files = originalGetScriptFileNames();
+      const virtualFiles = [...recordsByVirtualFile.keys()];
+      return [...new Set([...files, ...virtualFiles])];
+    };
+  }
+
+  host.fileExists = (path: string): boolean => {
+    if (recordsByVirtualFile.has(path)) return true;
+    const parsed = parsePreviewUri(path);
+    if (parsed) {
+      if ("virtualPath" in parsed) {
+        if (recordsByVirtualFile.has(parsed.virtualPath)) return true;
+      } else {
+        const resolved = getOrBuildRecord(parsed.id, parsed.importer);
+        if (resolved.status === "resolved") return true;
+      }
+    }
+    return originalFileExists ? originalFileExists(path) : false;
+  };
+
+  host.readFile = (path: string): string | undefined => {
+    let record = recordsByVirtualFile.get(path);
+    if (!record) {
+      const parsed = parsePreviewUri(path);
+      if (parsed) {
+        if ("virtualPath" in parsed) {
+          record = recordsByVirtualFile.get(parsed.virtualPath) ?? undefined;
+        } else {
+          const resolved = getOrBuildRecord(parsed.id, parsed.importer);
+          if (resolved.status === "resolved") record = resolved.record;
+        }
+      }
+    }
+    if (record) return rebuildRecordIfNeeded(record).sourceText;
+    return originalReadFile?.(path);
+  };
+
+  options.languageService.getSemanticDiagnostics = (fileName: string): ts.Diagnostic[] => {
+    const diagnostics = originalGetSemanticDiagnostics(fileName);
+    const adapterDiagnostics = diagnosticsByFile.get(fileName);
+    if (!adapterDiagnostics || adapterDiagnostics.length === 0) {
+      return [...diagnostics];
+    }
+    return [...diagnostics, ...adapterDiagnostics];
+  };
+
+  options.languageService.getSyntacticDiagnostics = (
+    fileName: string,
+  ): ts.DiagnosticWithLocation[] => {
+    const diagnostics = originalGetSyntacticDiagnostics(fileName);
+    const adapterDiagnostics = diagnosticsByFile.get(fileName);
+    if (!adapterDiagnostics || adapterDiagnostics.length === 0) {
+      return [...diagnostics];
+    }
+    const withLocation = adapterDiagnostics.filter(
+      (d): d is ts.DiagnosticWithLocation => d.file !== undefined,
+    );
+    return [...diagnostics, ...withLocation];
+  };
+
+  return {
+    dispose(): void {
+      for (const [virtualPath] of recordsByVirtualFile) {
+        if (virtualPath.includes(VIRTUAL_NODE_MODULES_RELATIVE)) {
+          try {
+            unlinkSync(virtualPath);
+          } catch {
+            /* ignore */
+          }
+        }
+      }
+      (host as Mutable<ts.LanguageServiceHost>).resolveModuleNameLiterals =
+        originalResolveModuleNameLiterals;
+      host.resolveModuleNames = originalResolveModuleNames;
+      if (originalGetScriptSnapshot) {
+        host.getScriptSnapshot = originalGetScriptSnapshot;
+      }
+      if (originalGetScriptVersion) {
+        host.getScriptVersion = originalGetScriptVersion;
+      }
+      if (originalGetProjectVersion) {
+        host.getProjectVersion = originalGetProjectVersion;
+      }
+      if (originalGetScriptFileNames) {
+        host.getScriptFileNames = originalGetScriptFileNames;
+      }
+      if (originalFileExists) {
+        (host as { fileExists?: (path: string) => boolean }).fileExists = originalFileExists;
+      }
+      if (originalReadFile) {
+        (host as { readFile?: (path: string) => string | undefined }).readFile = originalReadFile;
+      }
+
+      options.languageService.getSemanticDiagnostics = originalGetSemanticDiagnostics;
+      options.languageService.getSyntacticDiagnostics = originalGetSyntacticDiagnostics;
+
+      store.dispose();
+      diagnosticsByFile.clear();
+    },
+  };
+};