@ttsc/unplugin 0.8.1 → 0.9.0

package/src/core/transform.ts

@@ -1,7 +1,7 @@
-import * as Diff from "diff-match-patch-es";
 import fs from "node:fs";
+import crypto from "node:crypto";
+import os from "node:os";
 import path from "node:path";
-import MagicString from "magic-string";
 import type {
   ITtscCompilerDiagnostic,
   ITtscCompilerTransformation,
@@ -21,11 +21,27 @@ export interface TtscTransformAlias {
   replacement: string;
 }
 
+export interface TtscCachedProjectTransform {
+  inputHashes: Record<string, string>;
+  projectRoot: string;
+  result: ITtscCompilerTransformation;
+}
+
+export type TtscTransformCache = Map<
+  string,
+  Promise<TtscCachedProjectTransform>
+>;
+
+export function createTtscTransformCache(): TtscTransformCache {
+  return new Map();
+}
+
 export async function transformTtsc(
   id: string,
   source: string,
   options: ResolvedTtscUnpluginOptions,
   aliases?: unknown,
+  cache?: TtscTransformCache,
 ): Promise<TtscTransformResult | undefined> {
   const clean = stripQuery(id);
   if (clean.includes("\0")) {
@@ -40,28 +56,45 @@ export async function transformTtsc(
   const tsconfigDir = path.dirname(tsconfig);
   const baseUrl = resolveBaseUrl(tsconfigDir, options.compilerOptions);
   const aliasPaths = createAliasPaths(baseUrl, aliases);
-  const configured = createTransformTsconfig({
+  const key = createTransformCacheKey({
     aliasPaths,
-    baseUrl,
     compilerOptions: options.compilerOptions,
+    plugins: options.plugins,
     tsconfig,
   });
-  try {
-    const effectiveTsconfig = configured.path;
-    const result = new TtscCompiler({
-      cwd: path.dirname(effectiveTsconfig),
+
+  let transformed = cache?.get(key);
+  if (transformed !== undefined) {
+    const cached = await transformed;
+    if (matchesCachedSource(cached, file, source)) {
+      reportSuccessDiagnostics(cached.result);
+      const code = selectTransformedSource({
+        file,
+        projectRoot: cached.projectRoot,
+        result: cached.result,
+      });
+      return createTransformResult(source, code);
+    }
+    cache?.delete(key);
+    transformed = undefined;
+  }
+
+  if (transformed === undefined) {
+    transformed = transformProject({
+      aliasPaths,
+      baseUrl,
+      compilerOptions: options.compilerOptions,
+      currentFile: file,
+      currentSource: source,
       plugins: options.plugins,
-      tsconfig: effectiveTsconfig,
-    }).transform();
-    const code = selectTransformedSource({
-      file,
-      projectRoot: path.dirname(effectiveTsconfig),
-      result,
+      tsconfig,
     });
-    return createTransformResult(source, code, file);
-  } finally {
-    configured.dispose();
+    cache?.set(key, transformed);
   }
+  const { projectRoot, result } = await transformed;
+  reportSuccessDiagnostics(result);
+  const code = selectTransformedSource({ file, projectRoot, result });
+  return createTransformResult(source, code);
 }
 
 export function stripQuery(id: string): string {
@@ -79,49 +112,157 @@ export function isDeclarationFile(id: string): boolean {
 export function createTransformResult(
   source: string,
   code: string,
-  id: string,
 ): TtscTransformResult | undefined {
   if (source === code) {
     return undefined;
   }
+  return { code };
+}
 
-  const magic = new MagicString(source);
-  const diff = Diff.diff(source, code);
-  Diff.diffCleanupSemantic(diff);
+function matchesCachedSource(
+  cached: TtscCachedProjectTransform,
+  file: string,
+  source: string,
+): boolean {
+  const currentKey = toProjectKey(cached.projectRoot, file);
+  const currentHashes = collectProjectInputHashes(cached.projectRoot);
+  currentHashes[currentKey] = hashText(source);
+  return sameHashes(cached.inputHashes, currentHashes);
+}
 
-  let offset = 0;
-  for (let index = 0; index < diff.length; index += 1) {
-    const [type, text] = diff[index]!;
-    if (type === 0) {
-      offset += text.length;
-      continue;
+function collectInputHashes(props: {
+  currentFile: string;
+  currentSource: string;
+  projectRoot: string;
+  result: ITtscCompilerTransformation;
+}): Record<string, string> {
+  const hashes = collectProjectInputHashes(props.projectRoot);
+  if (props.result.type !== "exception") {
+    for (const key of Object.keys(props.result.typescript)) {
+      const file = path.resolve(props.projectRoot, key);
+      try {
+        hashes[key] = hashText(fs.readFileSync(file, "utf8"));
+      } catch {
+        // A plugin may synthesize a virtual TypeScript file. It should not
+        // decide cache reuse for real source files.
+      }
     }
-    if (type === 1) {
-      magic.prependLeft(offset, text);
-      continue;
+  }
+  hashes[toProjectKey(props.projectRoot, props.currentFile)] = hashText(
+    props.currentSource,
+  );
+  return hashes;
+}
+
+function collectProjectInputHashes(
+  projectRoot: string,
+): Record<string, string> {
+  const hashes: Record<string, string> = {};
+  for (const file of listProjectInputFiles(projectRoot)) {
+    try {
+      hashes[toProjectKey(projectRoot, file)] = hashText(fs.readFileSync(file));
+    } catch {
+      // File watchers may observe a transform while another process is moving
+      // or deleting files. The missing key invalidates older cache entries.
     }
+  }
+  return hashes;
+}
 
-    const next = diff[index + 1];
-    if (next?.[0] === 1) {
-      magic.update(offset, offset + text.length, next[1]);
-      index += 1;
-    } else {
-      magic.remove(offset, offset + text.length);
+function listProjectInputFiles(root: string): string[] {
+  const out: string[] = [];
+  const stack = [root];
+  while (stack.length !== 0) {
+    const current = stack.pop()!;
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (isIgnoredProjectDirectory(entry.name)) {
+        continue;
+      }
+      const file = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(file);
+      } else if (entry.isFile()) {
+        out.push(file);
+      }
     }
-    offset += text.length;
   }
+  out.sort();
+  return out;
+}
 
-  if (!magic.hasChanged()) {
-    return undefined;
+function isIgnoredProjectDirectory(name: string): boolean {
+  return (
+    name === ".git" ||
+    name === ".ttsc" ||
+    name === ".cache" ||
+    name === ".next" ||
+    name === ".nuxt" ||
+    name === ".svelte-kit" ||
+    name === ".turbo" ||
+    name === ".vite" ||
+    name === "build" ||
+    name === "coverage" ||
+    name === "dist" ||
+    name === "node_modules" ||
+    name === "out" ||
+    name === "temp" ||
+    name === "tmp"
+  );
+}
+
+function sameHashes(
+  left: Record<string, string>,
+  right: Record<string, string>,
+): boolean {
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) {
+    return false;
+  }
+  return leftKeys.every((key) => right[key] === left[key]);
+}
+
+function hashText(input: string | Buffer): string {
+  return crypto.createHash("sha256").update(input).digest("hex");
+}
+
+async function transformProject(props: {
+  aliasPaths: Record<string, string[]>;
+  baseUrl: string;
+  compilerOptions: Record<string, unknown>;
+  currentFile: string;
+  currentSource: string;
+  plugins?: ResolvedTtscUnpluginOptions["plugins"];
+  tsconfig: string;
+}): Promise<TtscCachedProjectTransform> {
+  const configured = createTransformTsconfig(props);
+  const projectRoot = path.dirname(props.tsconfig);
+  try {
+    const result = new TtscCompiler({
+      cwd: projectRoot,
+      plugins: props.plugins,
+      projectRoot,
+      tsconfig: configured.path,
+    }).transform();
+    return {
+      inputHashes: collectInputHashes({
+        currentFile: props.currentFile,
+        currentSource: props.currentSource,
+        projectRoot,
+        result,
+      }),
+      projectRoot,
+      result,
+    };
+  } finally {
+    configured.dispose();
   }
-  return {
-    code: magic.toString(),
-    map: magic.generateMap({
-      file: `${id}.map`,
-      includeContent: true,
-      source: id,
-    }),
-  };
 }
 
 function createTransformTsconfig(props: {
@@ -130,10 +271,13 @@ function createTransformTsconfig(props: {
   compilerOptions: Record<string, unknown>;
   tsconfig: string;
 }): { path: string; dispose: () => void } {
-  const compilerOptions = {
-    ...props.compilerOptions,
-    ...createAliasCompilerOptions(props),
-  };
+  const compilerOptions = normalizeCompilerOptionsForGeneratedTsconfig(
+    {
+      ...props.compilerOptions,
+      ...createAliasCompilerOptions(props),
+    },
+    path.dirname(props.tsconfig),
+  );
   if (Object.keys(compilerOptions).length === 0) {
     return {
       path: props.tsconfig,
@@ -141,18 +285,13 @@ function createTransformTsconfig(props: {
     };
   }
 
-  const directory = path.dirname(props.tsconfig);
-  const file = path.join(
-    directory,
-    `.ttsc-unplugin-${process.pid}-${Date.now()}-${Math.random()
-      .toString(36)
-      .slice(2)}.json`,
-  );
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-unplugin-"));
+  const file = path.join(directory, "tsconfig.json");
   fs.writeFileSync(
     file,
     JSON.stringify(
       {
-        extends: `./${path.basename(props.tsconfig)}`,
+        extends: normalizePath(props.tsconfig),
         compilerOptions,
       },
       null,
@@ -162,10 +301,55 @@ function createTransformTsconfig(props: {
   );
   return {
     path: file,
-    dispose: () => fs.rmSync(file, { force: true }),
+    dispose: () => fs.rmSync(directory, { force: true, recursive: true }),
   };
 }
 
+function normalizeCompilerOptionsForGeneratedTsconfig(
+  compilerOptions: Record<string, unknown>,
+  tsconfigDir: string,
+): Record<string, unknown> {
+  const output = { ...compilerOptions };
+  for (const key of ["baseUrl", "declarationDir", "outDir", "rootDir"]) {
+    if (typeof output[key] === "string") {
+      output[key] = path.resolve(tsconfigDir, output[key]);
+    }
+  }
+  for (const key of ["rootDirs", "typeRoots"]) {
+    if (Array.isArray(output[key])) {
+      output[key] = output[key].map((entry) =>
+        typeof entry === "string" ? path.resolve(tsconfigDir, entry) : entry,
+      );
+    }
+  }
+  if (hasPaths(output.paths) && typeof output.baseUrl !== "string") {
+    output.baseUrl = tsconfigDir;
+  }
+  if (Array.isArray(output.plugins)) {
+    output.plugins = output.plugins.map((entry) =>
+      normalizePluginConfigForGeneratedTsconfig(entry, tsconfigDir),
+    );
+  }
+  return output;
+}
+
+function normalizePluginConfigForGeneratedTsconfig(
+  entry: unknown,
+  tsconfigDir: string,
+): unknown {
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+    return entry;
+  }
+  const output: Record<string, unknown> = { ...entry };
+  for (const key of ["config", "source", "transform"]) {
+    const value = output[key];
+    if (typeof value === "string" && isRelativeSpecifier(value)) {
+      output[key] = path.resolve(tsconfigDir, value);
+    }
+  }
+  return output;
+}
+
 function createAliasCompilerOptions(props: {
   aliasPaths: Record<string, string[]>;
   baseUrl: string;
@@ -183,6 +367,15 @@ function createAliasCompilerOptions(props: {
   };
 }
 
+function hasPaths(value: unknown): boolean {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    Object.keys(value).length !== 0
+  );
+}
+
 function readPaths(value: unknown): Record<string, string[]> {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return {};
@@ -260,6 +453,44 @@ function normalizeAliases(aliases: unknown): TtscTransformAlias[] {
   return [];
 }
 
+function createTransformCacheKey(props: {
+  aliasPaths: Record<string, string[]>;
+  compilerOptions: Record<string, unknown>;
+  plugins?: ResolvedTtscUnpluginOptions["plugins"];
+  tsconfig: string;
+}): string {
+  return stableStringify({
+    aliasPaths: props.aliasPaths,
+    compilerOptions: props.compilerOptions,
+    plugins: props.plugins,
+    tsconfig: path.resolve(props.tsconfig),
+  });
+}
+
+function stableStringify(value: unknown): string {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function isRelativeSpecifier(value: string): boolean {
+  return (
+    value === "." ||
+    value === ".." ||
+    value.startsWith("./") ||
+    value.startsWith("../") ||
+    value.startsWith(".\\") ||
+    value.startsWith("..\\")
+  );
+}
+
 function isAlias(value: unknown): value is TtscTransformAlias {
   return (
     typeof value === "object" &&
@@ -296,6 +527,16 @@ function selectTransformedSource(props: {
   throw new Error(`ttsc transform did not return output for ${props.file}`);
 }
 
+function reportSuccessDiagnostics(result: ITtscCompilerTransformation): void {
+  if (result.type !== "success" || result.diagnostics === undefined) {
+    return;
+  }
+  const text = formatDiagnostics(result.diagnostics);
+  if (text.length !== 0) {
+    process.stderr.write(`${text}\n`);
+  }
+}
+
 function formatDiagnostics(diagnostics: ITtscCompilerDiagnostic[]): string {
   if (diagnostics.length === 0) {
     return "ttsc transform failed";