@ttsc/unplugin 0.18.4 → 0.19.0

package/src/core/transform.ts

@@ -147,10 +147,14 @@ export async function transformTtsc(
 
   let transformed = cache?.get(key);
   if (transformed !== undefined) {
-    const cached = await transformed;
+    // A rejected in-flight generation must not stay cached: evict it (only if
+    // it is still the current entry) so a later call re-runs the transform.
+    const cached = await awaitOrEvict(cache, key, transformed);
     if (matchesCachedSource(cached, file, source)) {
       reportSuccessDiagnostics(cached.result);
-      const code = selectTransformedSource({
+      // A resolved `"exception"` / `"failure"` envelope makes this throw; that
+      // is a failed generation too, so evict before surfacing it.
+      const code = selectOrEvict(cache, key, transformed, {
         file,
         projectRoot: cached.projectRoot,
         result: cached.result,
@@ -177,13 +181,80 @@ export async function transformTtsc(
     });
     cache?.set(key, transformed);
   }
-  const { projectRoot, result } = await transformed;
+  const generation = transformed;
+  const { projectRoot, result } = await awaitOrEvict(cache, key, generation);
   reportSuccessDiagnostics(result);
-  const code = selectTransformedSource({ file, projectRoot, result });
+  const code = selectOrEvict(cache, key, generation, {
+    file,
+    projectRoot,
+    result,
+  });
   notifyFileDependencies(hooks, { file, projectRoot, result });
   return createTransformResult(source, code);
 }
 
+/**
+ * Await a cached generation, evicting it on rejection.
+ *
+ * The cache stores the in-flight transform Promise before it settles so
+ * concurrent callers share one compilation. A rejected generation must not
+ * remain the authoritative cached result, or a transient toolchain/host failure
+ * becomes permanent for a long-lived worker. Eviction is identity-guarded so a
+ * newer generation another caller installed under the same key survives.
+ */
+async function awaitOrEvict(
+  cache: TtscTransformCache | undefined,
+  key: string,
+  generation: Promise<TtscCachedProjectTransform>,
+): Promise<TtscCachedProjectTransform> {
+  try {
+    return await generation;
+  } catch (error) {
+    evictGeneration(cache, key, generation);
+    throw error;
+  }
+}
+
+/**
+ * Extract the transformed source, evicting the generation when the result is a
+ * host `"exception"` or compiler `"failure"` (which makes
+ * {@link selectTransformedSource} throw). Such a failed generation must not be
+ * replayed to later callers of an unchanged module.
+ */
+function selectOrEvict(
+  cache: TtscTransformCache | undefined,
+  key: string,
+  generation: Promise<TtscCachedProjectTransform>,
+  props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+  },
+): string {
+  try {
+    return selectTransformedSource(props);
+  } catch (error) {
+    evictGeneration(cache, key, generation);
+    throw error;
+  }
+}
+
+/**
+ * Delete a failed generation from the cache only when it is still the entry
+ * stored under `key`. The identity check prevents an older failed generation's
+ * cleanup from removing a newer replacement created by another caller for the
+ * same key.
+ */
+function evictGeneration(
+  cache: TtscTransformCache | undefined,
+  key: string,
+  generation: Promise<TtscCachedProjectTransform>,
+): void {
+  if (cache?.get(key) === generation) {
+    cache.delete(key);
+  }
+}
+
 /**
  * Forward the plugin-reported dependency list for `file` to the adapter's
  * `addWatchFile` hook.
@@ -462,6 +533,13 @@ async function transformProject(props: {
   try {
     const result = new TtscCompiler({
       cwd: projectRoot,
+      // The generated tsconfig (if any) lives in the system temp directory,
+      // so declare the real project as the plugin config anchor: utility
+      // plugin config discovery (banner.config.*, strip.config.*,
+      // lint.config.*) and relative configFile resolution walk the project,
+      // never the temp tree. In the passthrough case this equals the
+      // tsconfig's own directory, the default anchor.
+      pluginConfigDir: projectRoot,
       plugins: props.plugins,
       projectRoot,
       tsconfig: configured.path,
@@ -568,6 +646,14 @@ function normalizeCompilerOptionsForGeneratedTsconfig(
   return output;
 }
 
+/**
+ * Absolutize the relative path-typed keys of one plugin entry before it is
+ * written into the generated temp-dir tsconfig: `config`/`source`/`transform`
+ * are the descriptor-resolution keys, and `configFile` is the config-file
+ * override accepted by the shipped utility plugins (`@ttsc/banner`,
+ * `@ttsc/strip`, `@ttsc/lint`). Left relative, each would resolve against the
+ * temp directory instead of the project.
+ */
 function normalizePluginConfigForGeneratedTsconfig(
   entry: unknown,
   tsconfigDir: string,
@@ -576,7 +662,7 @@ function normalizePluginConfigForGeneratedTsconfig(
     return entry;
   }
   const output: Record<string, unknown> = { ...entry };
-  for (const key of ["config", "source", "transform"]) {
+  for (const key of ["config", "configFile", "source", "transform"]) {
     const value = output[key];
     if (typeof value === "string" && isRelativeSpecifier(value)) {
       output[key] = path.resolve(tsconfigDir, value);

package/src/core/tsconfigPaths.ts

@@ -148,6 +148,15 @@ function resolveExtendsConfig(
     );
   }
   const resolver = createRequire(tsconfig);
+  // A bare package root selects its preset through `package.json#tsconfig`,
+  // matching TypeScript's config resolution and the core project reader. Such
+  // presets often ship no JS/JSON entrypoint, so Node's entrypoint resolver and
+  // the `<specifier>.json` fallback both miss them, silently dropping the
+  // preset's inherited `paths`.
+  const viaManifest = resolvePackageManifestTsconfig(resolver, specifier);
+  if (viaManifest !== null) {
+    return viaManifest;
+  }
   try {
     return resolveRealPath(resolver.resolve(specifier));
   } catch {
@@ -159,6 +168,58 @@ function resolveExtendsConfig(
   }
 }
 
+/**
+ * When `specifier` names a bare package root, resolve the config file its
+ * `package.json#tsconfig` field selects (anchored at the package directory).
+ * Best-effort: returns `null` for a subpath, an unresolvable/unparsable
+ * manifest, a missing `tsconfig` field, or a field target that does not exist —
+ * the compiler owns the real diagnostic, and this reader must not invent
+ * aliases.
+ */
+function resolvePackageManifestTsconfig(
+  resolver: NodeRequire,
+  specifier: string,
+): string | null {
+  if (!isBarePackageRoot(specifier)) {
+    return null;
+  }
+  let manifestPath: string;
+  try {
+    manifestPath = resolver.resolve(`${specifier}/package.json`);
+  } catch {
+    return null;
+  }
+  let field: unknown;
+  try {
+    const text = fs.readFileSync(manifestPath, "utf8");
+    field = (
+      JSON.parse(text.charCodeAt(0) === 0xfeff ? text.slice(1) : text) as {
+        tsconfig?: unknown;
+      }
+    ).tsconfig;
+  } catch {
+    return null;
+  }
+  if (typeof field !== "string" || field.length === 0) {
+    return null;
+  }
+  return resolveExistingExtendsPath(
+    path.resolve(path.dirname(manifestPath), field),
+  );
+}
+
+/**
+ * Return true when `specifier` is a bare package root (no subpath): a plain
+ * package name (`preset`) or a scoped name (`@scope/preset`). Subpaths such as
+ * `@scope/preset/base.json` resolve directly and keep their current meaning.
+ */
+function isBarePackageRoot(specifier: string): boolean {
+  if (specifier.startsWith("@")) {
+    return specifier.split("/").length === 2;
+  }
+  return !specifier.includes("/");
+}
+
 /**
  * Try an on-disk `extends` location as-is, with `.json` appended, and as a
  * directory containing `tsconfig.json`. Returns the first existing match.

package/src/turbopack.ts

@@ -21,6 +21,14 @@ export interface TtscTurbopackLoaderContext {
   resourcePath: string;
   /** The rule's `options` object, when one was configured. */
   getOptions?(): TtscUnpluginOptions | undefined;
+  /**
+   * Register an additional file the transformed module depends on. Part of the
+   * webpack loader context contract Turbopack implements; a registered file
+   * enters Turbopack's `fileDependencies` set so editing it re-runs this loader
+   * for the owning module. Optional so a minimal stub context (or a Turbopack
+   * build that predates the method) still loads.
+   */
+  addDependency?(file: string): void;
 }
 
 /** Matches any path segment that is a `node_modules` directory (cross-platform). */
@@ -71,12 +79,19 @@ export default function turbopack(
     callback(undefined, source);
     return;
   }
+  // Forward plugin-reported dependencies into Turbopack's `fileDependencies`
+  // set so editing a type-only input a transform consulted re-runs this loader.
+  // `addDependency` is bound so the webpack loader context stays `this` inside
+  // it; the hook fires on cache hits too, which is required because the shared
+  // transform cache lives for the worker lifetime across requests.
+  const addDependency = this.addDependency?.bind(this);
   transformTtsc(
     file,
     source,
     resolveOptions(this.getOptions?.() ?? {}),
     undefined,
     transformCache,
+    addDependency === undefined ? undefined : { addWatchFile: addDependency },
   ).then(
     (result) => callback(undefined, result?.code ?? source),
     (error) => callback(error),