@ttsc/unplugin 0.15.2 → 0.15.3

package/src/core/transform.ts

@@ -10,6 +10,10 @@ import { TtscCompiler } from "ttsc";
 import type { TransformResult } from "unplugin";
 
 import type { ResolvedTtscUnpluginOptions } from "./options";
+import {
+  absolutizePathsTarget,
+  readEffectiveTsconfigPaths,
+} from "./tsconfigPaths";
 
 /**
  * The normalised transform result type that this module produces.
@@ -71,6 +75,21 @@ export function createTtscTransformCache(): TtscTransformCache {
   return new Map();
 }
 
+/**
+ * Hooks the bundler adapter passes into {@link transformTtsc} so transform
+ * side-channels (currently the plugin-reported dependency list) reach the
+ * bundler without leaking extra fields on the returned `TransformResult`.
+ */
+export interface TtscTransformHooks {
+  /**
+   * Invoked once per absolute dependency path the plugin reported for the
+   * transformed file (`dependencies` in the transform envelope). Adapters
+   * forward this to the bundler's `addWatchFile` so type-only inputs
+   * participate in HMR invalidation.
+   */
+  addWatchFile?: (file: string) => void;
+}
+
 /**
  * Apply the ttsc plugin transform to a single source file.
  *
@@ -90,6 +109,9 @@ export function createTtscTransformCache(): TtscTransformCache {
  *   object).
  * @param cache - Optional per-build cache; cleared by the caller on
  *   `buildStart`.
+ * @param hooks - Optional adapter callbacks; see {@link TtscTransformHooks}.
+ *   Dependency notifications fire on cache hits too — watch registrations are
+ *   per build, not per compilation.
  */
 export async function transformTtsc(
   id: string,
@@ -97,6 +119,7 @@ export async function transformTtsc(
   options: ResolvedTtscUnpluginOptions,
   aliases?: unknown,
   cache?: TtscTransformCache,
+  hooks?: TtscTransformHooks,
 ): Promise<TtscTransformResult | undefined> {
   const clean = stripQuery(id);
   if (clean.includes("\0")) {
@@ -111,9 +134,7 @@ export async function transformTtsc(
   }
 
   const tsconfig = resolveTsconfig(file, options.project);
-  const tsconfigDir = path.dirname(tsconfig);
-  const baseUrl = resolveBaseUrl(tsconfigDir, options.compilerOptions);
-  const aliasPaths = createAliasPaths(baseUrl, aliases);
+  const aliasPaths = createAliasPaths(aliases);
   const key = createTransformCacheKey({
     aliasPaths,
     compilerOptions: options.compilerOptions,
@@ -131,6 +152,11 @@ export async function transformTtsc(
         projectRoot: cached.projectRoot,
         result: cached.result,
       });
+      notifyFileDependencies(hooks, {
+        file,
+        projectRoot: cached.projectRoot,
+        result: cached.result,
+      });
       return createTransformResult(source, code);
     }
     cache?.delete(key);
@@ -140,7 +166,6 @@ export async function transformTtsc(
   if (transformed === undefined) {
     transformed = transformProject({
       aliasPaths,
-      baseUrl,
       compilerOptions: options.compilerOptions,
       currentFile: file,
       currentSource: source,
@@ -152,9 +177,83 @@ export async function transformTtsc(
   const { projectRoot, result } = await transformed;
   reportSuccessDiagnostics(result);
   const code = selectTransformedSource({ file, projectRoot, result });
+  notifyFileDependencies(hooks, { file, projectRoot, result });
   return createTransformResult(source, code);
 }
 
+/**
+ * Forward the plugin-reported dependency list for `file` to the adapter's
+ * `addWatchFile` hook.
+ *
+ * The transform envelope's `dependencies` keys mirror the `typescript` keys
+ * (project-relative); values may be project-relative or absolute. Every path is
+ * absolutized against the project root and deduplicated, and the file itself is
+ * dropped — the bundler already watches the module it transforms.
+ */
+function notifyFileDependencies(
+  hooks: TtscTransformHooks | undefined,
+  props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+  },
+): void {
+  const addWatchFile = hooks?.addWatchFile;
+  if (addWatchFile === undefined) {
+    return;
+  }
+  for (const dependency of selectFileDependencies(props)) {
+    addWatchFile(dependency);
+  }
+}
+
+/**
+ * Extract the absolute, deduplicated dependency list for a single file from the
+ * compiler result. Mirrors {@link selectTransformedSource}'s key lookup: fast
+ * project-relative match first, then a resolve-based scan. Returns an empty
+ * list on exceptions or when the plugin reported nothing.
+ */
+function selectFileDependencies(props: {
+  file: string;
+  projectRoot: string;
+  result: ITtscCompilerTransformation;
+}): string[] {
+  if (props.result.type === "exception") {
+    return [];
+  }
+  const dependencies = props.result.dependencies;
+  if (dependencies === undefined) {
+    return [];
+  }
+  const key = toProjectKey(props.projectRoot, props.file);
+  let entries = dependencies[key];
+  if (entries === undefined) {
+    for (const [candidate, candidateEntries] of Object.entries(dependencies)) {
+      if (path.resolve(props.projectRoot, candidate) === props.file) {
+        entries = candidateEntries;
+        break;
+      }
+    }
+  }
+  if (!Array.isArray(entries)) {
+    return [];
+  }
+  const output: string[] = [];
+  const seen = new Set<string>();
+  for (const entry of entries) {
+    if (typeof entry !== "string" || entry.length === 0) {
+      continue;
+    }
+    const absolute = path.resolve(props.projectRoot, entry);
+    if (absolute === props.file || seen.has(absolute)) {
+      continue;
+    }
+    seen.add(absolute);
+    output.push(absolute);
+  }
+  return output;
+}
+
 /**
  * Strip a query string or hash fragment from a bundler module id.
  *
@@ -337,7 +436,6 @@ function hashText(input: string | Buffer): string {
 
 async function transformProject(props: {
   aliasPaths: Record<string, string[]>;
-  baseUrl: string;
   compilerOptions: Record<string, unknown>;
   currentFile: string;
   currentSource: string;
@@ -370,7 +468,6 @@ async function transformProject(props: {
 
 function createTransformTsconfig(props: {
   aliasPaths: Record<string, string[]>;
-  baseUrl: string;
   compilerOptions: Record<string, unknown>;
   tsconfig: string;
 }): { path: string; dispose: () => void } {
@@ -416,9 +513,10 @@ function createTransformTsconfig(props: {
  * tsconfig must be converted to an absolute path before writing the generated
  * file. Otherwise TypeScript-Go resolves it against the temp dir.
  *
- * Also inserts a synthetic `baseUrl` equal to `tsconfigDir` when `paths` is
- * provided but `baseUrl` is absent — TypeScript requires `baseUrl` alongside
- * `paths` when the latter contains non-absolute targets.
+ * `paths` targets are absolutized for the same reason, with the extra twist
+ * that TypeScript-Go rejects bare non-relative targets outright (TS5090) and
+ * has removed `baseUrl` (TS5102), so anchoring them as absolute paths is the
+ * only temp-dir-safe encoding. No synthetic `baseUrl` is ever written.
  */
 function normalizeCompilerOptionsForGeneratedTsconfig(
   compilerOptions: Record<string, unknown>,
@@ -426,7 +524,7 @@ function normalizeCompilerOptionsForGeneratedTsconfig(
 ): Record<string, unknown> {
   const output = { ...compilerOptions };
   // Scalar path fields: resolve each against the original tsconfig directory.
-  for (const key of ["baseUrl", "declarationDir", "outDir", "rootDir"]) {
+  for (const key of ["declarationDir", "outDir", "rootDir"]) {
     if (typeof output[key] === "string") {
       output[key] = path.resolve(tsconfigDir, output[key]);
     }
@@ -439,8 +537,14 @@ function normalizeCompilerOptionsForGeneratedTsconfig(
       );
     }
   }
-  if (hasPaths(output.paths) && typeof output.baseUrl !== "string") {
-    output.baseUrl = tsconfigDir;
+  const paths = readPaths(output.paths);
+  if (Object.keys(paths).length !== 0) {
+    output.paths = Object.fromEntries(
+      Object.entries(paths).map(([key, targets]) => [
+        key,
+        targets.map((target) => absolutizePathsTarget(tsconfigDir, target)),
+      ]),
+    );
   }
   if (Array.isArray(output.plugins)) {
     output.plugins = output.plugins.map((entry) =>
@@ -467,32 +571,37 @@ function normalizePluginConfigForGeneratedTsconfig(
   return output;
 }
 
+/**
+ * Build the `paths` overlay that forwards bundler aliases to the compiler.
+ *
+ * Because the generated tsconfig `extends` the project one and TypeScript
+ * merges `compilerOptions` per option key, declaring `paths` here replaces the
+ * project's own `paths` wholesale. The overlay therefore re-states the
+ * project's effective mappings first, so tsconfig-only aliases keep resolving;
+ * inline `compilerOptions.paths` from the plugin options ride on top, and the
+ * bundler aliases win last — they mirror what the bundler will actually do at
+ * resolve time.
+ *
+ * No `baseUrl` is emitted: TypeScript-Go removed the option (TS5102), and all
+ * targets are absolute so none is needed.
+ */
 function createAliasCompilerOptions(props: {
   aliasPaths: Record<string, string[]>;
-  baseUrl: string;
   compilerOptions: Record<string, unknown>;
+  tsconfig: string;
 }): Record<string, unknown> {
   if (Object.keys(props.aliasPaths).length === 0) {
     return {};
   }
   return {
-    baseUrl: toCompilerPath(props.baseUrl, props.compilerOptions),
     paths: {
+      ...readEffectiveTsconfigPaths(props.tsconfig),
       ...readPaths(props.compilerOptions.paths),
       ...props.aliasPaths,
     },
   };
 }
 
-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 {};
@@ -512,28 +621,14 @@ function readPaths(value: unknown): Record<string, string[]> {
   return output;
 }
 
-function resolveBaseUrl(
-  tsconfigDir: string,
-  compilerOptions: Record<string, unknown>,
-): string {
-  return typeof compilerOptions.baseUrl === "string"
-    ? path.resolve(tsconfigDir, compilerOptions.baseUrl)
-    : tsconfigDir;
-}
-
-function toCompilerPath(
-  absoluteBaseUrl: string,
-  compilerOptions: Record<string, unknown>,
-): string {
-  return typeof compilerOptions.baseUrl === "string"
-    ? compilerOptions.baseUrl
-    : absoluteBaseUrl;
-}
-
-function createAliasPaths(
-  baseUrl: string,
-  aliases: unknown,
-): Record<string, string[]> {
+/**
+ * Convert bundler aliases into absolute `paths` mappings.
+ *
+ * Targets are written as absolute paths on purpose: the generated tsconfig
+ * lives in a system temp directory, where TypeScript-Go would reject bare
+ * relative targets (TS5090) and anchor `./`-style ones at the wrong directory.
+ */
+function createAliasPaths(aliases: unknown): Record<string, string[]> {
   const paths: Record<string, string[]> = {};
   for (const alias of normalizeAliases(aliases)) {
     if (typeof alias.find !== "string" || alias.find.length === 0) {
@@ -546,10 +641,11 @@ function createAliasPaths(
     if (key.length === 0) {
       continue;
     }
-    const replacement = path.isAbsolute(alias.replacement)
-      ? alias.replacement
-      : path.resolve(process.cwd(), alias.replacement);
-    const target = normalizePath(path.relative(baseUrl, replacement) || ".");
+    const target = normalizePath(
+      path.isAbsolute(alias.replacement)
+        ? alias.replacement
+        : path.resolve(process.cwd(), alias.replacement),
+    );
     paths[key] = [target];
     paths[`${key}/*`] = [`${target}/*`];
   }

package/src/core/tsconfigPaths.ts

@@ -0,0 +1,338 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+/**
+ * Read the effective `compilerOptions.paths` of a tsconfig, following its
+ * `extends` chain, and absolutize every mapping target.
+ *
+ * TypeScript merges `compilerOptions` per option key, so the effective `paths`
+ * is the whole object from the nearest config in the chain that declares one
+ * (own config first, then `extends` entries in reverse priority order).
+ * Relative targets are anchored at the directory of the config that declares
+ * them — TypeScript-Go resolves inherited relative `paths` against the
+ * declaring file, not the extending one.
+ *
+ * The generated transform tsconfig replaces `paths` wholesale (standard
+ * `extends` semantics), so the alias overlay must re-state these base mappings
+ * or every tsconfig-only alias silently stops resolving. Absolutizing is
+ * required because the generated config lives in a system temp directory and
+ * TypeScript-Go rejects non-relative targets (TS5090) while accepting absolute
+ * ones.
+ *
+ * Best-effort by design: a missing or unparsable config in the chain yields
+ * `{}` here and a real config error from the compiler, which owns config
+ * diagnostics.
+ */
+export function readEffectiveTsconfigPaths(
+  tsconfig: string,
+): Record<string, string[]> {
+  const declared = findDeclaredPaths(path.resolve(tsconfig), new Set());
+  if (declared === null) {
+    return {};
+  }
+  const output: Record<string, string[]> = {};
+  for (const [key, targets] of Object.entries(declared.paths)) {
+    if (!Array.isArray(targets)) {
+      continue;
+    }
+    const absolute = targets
+      .filter((target): target is string => typeof target === "string")
+      .map((target) => absolutizePathsTarget(declared.baseDir, target));
+    if (absolute.length !== 0) {
+      output[key] = absolute;
+    }
+  }
+  return output;
+}
+
+/**
+ * Anchor a single `paths` target at `baseDir` unless it is already absolute,
+ * normalizing to forward slashes. The `*` wildcard survives `path.resolve` as a
+ * literal segment, so patterns like `./src/*` stay patterns.
+ */
+export function absolutizePathsTarget(baseDir: string, target: string): string {
+  const resolved = path.isAbsolute(target)
+    ? target
+    : path.resolve(baseDir, target);
+  return resolved.replace(/\\/g, "/");
+}
+
+/**
+ * The `paths` object found while walking one tsconfig's `extends` chain,
+ * together with the directory of the config that declared it (the anchor for
+ * relative targets).
+ */
+interface IDeclaredPaths {
+  baseDir: string;
+  paths: Record<string, unknown>;
+}
+
+/**
+ * Locate the nearest `compilerOptions.paths` declaration in the `extends` chain
+ * rooted at `tsconfig`. The own config wins over its bases; within an `extends`
+ * array, later entries win over earlier ones. `seen` breaks circular chains —
+ * the compiler reports the actual config error.
+ */
+function findDeclaredPaths(
+  tsconfig: string,
+  seen: Set<string>,
+): IDeclaredPaths | null {
+  const canonical = resolveRealPath(tsconfig);
+  if (seen.has(canonical)) {
+    return null;
+  }
+  seen.add(canonical);
+
+  let parsed: { extends?: unknown; compilerOptions?: { paths?: unknown } };
+  try {
+    parsed = parseJsonc(fs.readFileSync(canonical, "utf8")) as typeof parsed;
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return null;
+  }
+
+  const own = parsed.compilerOptions?.paths;
+  if (typeof own === "object" && own !== null && !Array.isArray(own)) {
+    return {
+      baseDir: path.dirname(canonical),
+      paths: own as Record<string, unknown>,
+    };
+  }
+
+  for (const specifier of extendsSpecifiers(parsed.extends).reverse()) {
+    const base = resolveExtendsConfig(canonical, specifier);
+    if (base === null) {
+      continue;
+    }
+    const declared = findDeclaredPaths(base, seen);
+    if (declared !== null) {
+      return declared;
+    }
+  }
+  return null;
+}
+
+/** Normalize the `extends` field into a list of string specifiers. */
+function extendsSpecifiers(extended: unknown): string[] {
+  if (typeof extended === "string") {
+    return [extended];
+  }
+  if (Array.isArray(extended)) {
+    return extended.filter(
+      (entry): entry is string => typeof entry === "string",
+    );
+  }
+  return [];
+}
+
+/**
+ * Resolve an `extends` specifier to an absolute config path using TypeScript's
+ * rules: absolute paths and relative specifiers get `.json` /
+ * `tsconfig.json`-directory fallbacks; bare specifiers go through Node's module
+ * resolver scoped to the declaring config. Returns `null` instead of throwing —
+ * the compiler reports unresolvable `extends` itself.
+ */
+function resolveExtendsConfig(
+  tsconfig: string,
+  specifier: string,
+): string | null {
+  if (path.isAbsolute(specifier)) {
+    return resolveExistingExtendsPath(specifier);
+  }
+  if (isRelativeSpecifier(specifier)) {
+    return resolveExistingExtendsPath(
+      path.resolve(path.dirname(tsconfig), specifier),
+    );
+  }
+  const resolver = createRequire(tsconfig);
+  try {
+    return resolveRealPath(resolver.resolve(specifier));
+  } catch {
+    try {
+      return resolveRealPath(resolver.resolve(`${specifier}.json`));
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * Try an on-disk `extends` location as-is, with `.json` appended, and as a
+ * directory containing `tsconfig.json`. Returns the first existing match.
+ */
+function resolveExistingExtendsPath(location: string): string | null {
+  for (const candidate of new Set([
+    location,
+    `${location}.json`,
+    path.join(location, "tsconfig.json"),
+  ])) {
+    if (fs.existsSync(candidate)) {
+      return resolveRealPath(candidate);
+    }
+  }
+  return null;
+}
+
+/**
+ * Return true when `specifier` is a relative path reference: `.`, `..`, or a
+ * string starting with `./`, `../`, `.\\`, or `..\\`.
+ */
+function isRelativeSpecifier(specifier: string): boolean {
+  return (
+    specifier === "." ||
+    specifier === ".." ||
+    specifier.startsWith("./") ||
+    specifier.startsWith("../") ||
+    specifier.startsWith(".\\") ||
+    specifier.startsWith("..\\")
+  );
+}
+
+/**
+ * Resolve symlinks on `location`, returning the original path when
+ * `realpathSync` fails (e.g. when the file does not exist).
+ */
+function resolveRealPath(location: string): string {
+  try {
+    return fs.realpathSync(location);
+  } catch {
+    return location;
+  }
+}
+
+/**
+ * Parse a JSONC (JSON with Comments) string by stripping comments and trailing
+ * commas before handing off to `JSON.parse`. A leading UTF-8 BOM is dropped —
+ * `JSON.parse` rejects it, and this reader must not lose `paths` for a config
+ * the compiler accepts.
+ */
+function parseJsonc(input: string): unknown {
+  const text = input.charCodeAt(0) === 0xfeff ? input.slice(1) : input;
+  return JSON.parse(stripTrailingCommas(stripComments(text)));
+}
+
+/**
+ * Remove `//` line comments and `/* block comments *\/` from a JSONC string.
+ * Correctly handles strings that contain comment-like character sequences by
+ * tracking string boundaries and escape characters.
+ */
+function stripComments(input: string): string {
+  let output = "";
+  let inBlockComment = false;
+  let inLineComment = false;
+  let inString = false;
+  let quote = "";
+  let escape = false;
+
+  for (let i = 0; i < input.length; i += 1) {
+    const current = input[i]!;
+    const next = input[i + 1];
+
+    if (inBlockComment) {
+      if (current === "*" && next === "/") {
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (inLineComment) {
+      if (current === "\n") {
+        inLineComment = false;
+        output += current;
+      }
+      continue;
+    }
+    if (inString) {
+      output += current;
+      if (escape) {
+        escape = false;
+      } else if (current === "\\") {
+        escape = true;
+      } else if (current === quote) {
+        inString = false;
+        quote = "";
+      }
+      continue;
+    }
+
+    if (current === '"' || current === "'") {
+      inString = true;
+      quote = current;
+      output += current;
+      continue;
+    }
+    if (current === "/" && next === "/") {
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    output += current;
+  }
+  return output;
+}
+
+/**
+ * Remove trailing commas before `}` or `]` from a JSON string (after comments
+ * have already been stripped). Handles string boundaries and escape characters
+ * to avoid removing commas inside string values.
+ */
+function stripTrailingCommas(input: string): string {
+  let output = "";
+  let inString = false;
+  let quote = "";
+  let escape = false;
+
+  for (let i = 0; i < input.length; i += 1) {
+    const current = input[i]!;
+    if (inString) {
+      output += current;
+      if (escape) {
+        escape = false;
+      } else if (current === "\\") {
+        escape = true;
+      } else if (current === quote) {
+        inString = false;
+        quote = "";
+      }
+      continue;
+    }
+
+    if (current === '"' || current === "'") {
+      inString = true;
+      quote = current;
+      output += current;
+      continue;
+    }
+    if (current === ",") {
+      const next = nextNonWhitespace(input, i + 1);
+      if (next === "}" || next === "]") {
+        continue;
+      }
+    }
+    output += current;
+  }
+  return output;
+}
+
+/**
+ * Return the first non-whitespace character at or after position `from` in
+ * `input`, or `undefined` when only whitespace remains. Used by
+ * `stripTrailingCommas` to detect whether a comma is trailing.
+ */
+function nextNonWhitespace(input: string, from: number): string | undefined {
+  for (let i = from; i < input.length; i += 1) {
+    const current = input[i]!;
+    if (/\s/.test(current) === false) {
+      return current;
+    }
+  }
+  return undefined;
+}