@ttsc/unplugin 0.28.2 → 0.28.4

package/src/core/index.ts

@@ -20,9 +20,13 @@ import { createViteServeMissingInputWatch } from "./viteServe";
 
 const name = "ttsc-unplugin";
 /**
- * Matches any TypeScript or JavaScript source extension (.ts, .tsx, .mts, .cts,
- * etc.). Shared with the Bun adapter (`bun.ts`) so the filter is defined once
- * and both adapters stay in sync.
+ * Matches the TypeScript source extensions the ttsc transform handles: `.ts`,
+ * `.tsx`, `.mts`, `.cts` and their `x` forms. JavaScript is deliberately not
+ * among them, so a `.js` module reaches no adapter's transform.
+ *
+ * Shared with the Bun adapter (`bun.ts`) and the standalone Turbopack loader
+ * (`turbopack.ts`) through {@link isTransformTarget}, so the filter is defined
+ * once and every adapter answers the same way.
  */
 export const sourceFilePattern = /\.[cm]?tsx?$/;
 /** Matches any path segment that is a `node_modules` directory (cross-platform). */
@@ -37,13 +41,15 @@ const virtualModulePattern = /\0/;
  * Unplugin factory that wires the ttsc transform pipeline into any supported
  * bundler (Vite, Rollup, Rolldown, webpack, Rspack, esbuild, Farm).
  *
- * The factory resolves raw options once, creates a per-build transform cache,
- * and captures Vite alias configuration via the `vite.configResolved` hook so
- * that path aliases are forwarded to the generated tsconfig overlay. Real build
- * lifecycles use a per-build cache; a watching Vite development server keeps
- * persistent validation because its one `buildStart` spans later HMR edits,
- * while a dev server configured without a watcher takes the build-scoped path
- * with them, having declared it will observe no edit at all.
+ * The factory resolves raw options once, creates one transform cache for the
+ * whole plugin instance, and captures Vite alias configuration via the
+ * `vite.configResolved` hook so that path aliases are forwarded to the
+ * generated tsconfig overlay. A host with a real `buildStart` opens a delivery
+ * pass there and keeps its generation across passes; a watching Vite
+ * development server keeps persistent validation instead, because its one
+ * `buildStart` spans later HMR edits and so cannot mark a pass, while a dev
+ * server configured without a watcher takes the pass lifecycle with them,
+ * having declared it will observe no edit at all.
  */
 const unpluginFactory: UnpluginFactory<
   TtscUnpluginOptions | undefined,
@@ -55,6 +61,17 @@ const unpluginFactory: UnpluginFactory<
   let aliases: unknown;
   let viteCommand: string | undefined;
   let viteWatching = true;
+  // Whether a build-mode session is driven by Rollup's watcher. `build.watch`
+  // is `null` for an ordinary build and an object under `--watch`, which is the
+  // axis the disposal boundary actually turns on: only a watching build repeats
+  // its build phase, and only a watching build ends at `closeWatcher`.
+  let viteBuildWatching = false;
+  // A restart can start the replacement plugin container before closing the
+  // old one, and Vite calls buildEnd even for a container that never started.
+  // Track the stable per-container PluginContext identity so that unstarted
+  // old containers cannot dispose a replacement's freshly initialized cache.
+  let viteBuildOwners = new WeakSet<object>();
+  let viteBuildLifecycles = 0;
 
   return {
     name,
@@ -78,6 +95,13 @@ const unpluginFactory: UnpluginFactory<
         // (samchon/ttsc#1246).
         viteWatching =
           (config as { server?: { watch?: unknown } }).server?.watch !== null;
+        // Read on the same principle as the line above, from the half of the
+        // config that governs a build rather than a server. The comparison is
+        // loose where the server's is strict because the two defaults differ:
+        // `server.watch` is an object unless explicitly `null`, while
+        // `build.watch` is absent or `null` unless `--watch` supplies one.
+        viteBuildWatching =
+          (config as { build?: { watch?: unknown } }).build?.watch != null;
       },
       // Vite serve funnels every transform-context `addWatchFile()` into the
       // module's added-import graph (`_addedImports`), which import-analysis
@@ -88,14 +112,94 @@ const unpluginFactory: UnpluginFactory<
       configureServer(server) {
         missingInputs.attach(server);
       },
-      // Vite calls buildEnd when the dev server (or build) closes; drop every
-      // poller so a stopped server leaks no watch state.
+      // Vite calls buildEnd when the dev server closes, and Rollup calls it at
+      // the end of every build phase; drop every poller and, once the last
+      // overlapping container has closed, every generation-owned filesystem
+      // tracker as well.
+      //
+      // Disposing here is right wherever the end of a build phase is also the
+      // end of the session: a dev server, and an ordinary one-shot build. It is
+      // wrong for a watching build, whose watcher repeats build phases, so it
+      // means "this pass ended" there — measured as
+      // `buildStart -> buildEnd -> ... -> buildStart -> buildEnd` across
+      // `vite build --watch` rebuilds. Disposing on that repeat discarded the
+      // generation once per rebuild independently of the `buildStart` clear, so
+      // fixing one of the two sites alone left this host recompiling the whole
+      // project per edit (samchon/ttsc#1301). The watching build hands its
+      // teardown to `closeWatcher` below instead.
       buildEnd() {
         missingInputs.dispose();
+        if (viteBuildOwners.delete(this)) {
+          viteBuildLifecycles -= 1;
+        }
+        if (
+          viteBuildLifecycles === 0 &&
+          (viteCommand === "serve" || !viteBuildWatching)
+        ) {
+          resetTtscTransformCache(transformCache);
+        }
+      },
+      // The watching build's real teardown, and the only hook in a
+      // `vite build --watch` trace that fires exactly once: buildEnd,
+      // writeBundle and closeBundle all repeat per rebuild there. A generation
+      // retained across passes owns directory watchers, so this is where they
+      // are released. Vite's dev server drives no Rollup watcher and an
+      // ordinary build closes its bundle instead, so neither reaches here;
+      // a host that fired both would simply reset twice, which is idempotent.
+      //
+      // The container bookkeeping is cleared with the cache, and the owner set
+      // is replaced rather than merely zeroed alongside it. A watcher closed
+      // mid-rebuild leaves a container still registered, and its later
+      // `buildEnd` would then decrement a counter that is already zero and
+      // strand it below zero, after which the disposal above could never fire
+      // again for this plugin instance.
+      closeWatcher() {
+        viteBuildOwners = new WeakSet<object>();
+        viteBuildLifecycles = 0;
+        resetTtscTransformCache(transformCache);
+      },
+    },
+
+    // Rollup and Rolldown carry none of the Vite block's hooks, so before this
+    // they had no disposal site at all. They get both halves of the same
+    // boundary: a watching session ends at `closeWatcher`, and a one-shot build
+    // ends when its build phase does. `this.meta.watchMode` separates the two
+    // there, the way `build.watch` does for Vite, so a one-shot build is not
+    // left without a site the way `vite build` was (samchon/ttsc#1301).
+    // unplugin merges each of these blocks only into its own adapter, so the
+    // Vite adapter never receives them.
+    //
+    // A `buildEnd` at the top level instead of inside a block would be a
+    // regression rather than a shorthand: unplugin forwards a top-level one to
+    // esbuild's `onEnd` and to webpack's and Rspack's `hooks.emit`, each of
+    // which repeats per rebuild, so those hosts would start discarding a valid
+    // generation on every edit, which is samchon/ttsc#1300 again.
+    rollup: {
+      buildEnd(this: { meta?: { watchMode?: boolean } }) {
+        if (this.meta?.watchMode !== true) {
+          resetTtscTransformCache(transformCache);
+        }
+      },
+      closeWatcher() {
+        resetTtscTransformCache(transformCache);
+      },
+    },
+    rolldown: {
+      buildEnd(this: { meta?: { watchMode?: boolean } }) {
+        if (this.meta?.watchMode !== true) {
+          resetTtscTransformCache(transformCache);
+        }
+      },
+      closeWatcher() {
+        resetTtscTransformCache(transformCache);
       },
     },
 
     buildStart() {
+      if (viteCommand !== undefined && !viteBuildOwners.has(this as object)) {
+        viteBuildOwners.add(this as object);
+        viteBuildLifecycles += 1;
+      }
       // Persistent validation exists for a session that spans edits it can
       // observe, and a dev server told to open no watcher is not one:
       // `server.watch: null` leaves Vite with no change channel at all, so no
@@ -103,14 +207,18 @@ const unpluginFactory: UnpluginFactory<
       // no client is hot-updated. Validating each delivery there does not buy
       // freshness, it buys incoherence — modules delivered before an edit and
       // after it would come from two different compilations of one program —
-      // while costing a full derived-input proof per delivered module. The
-      // build-scoped lifecycle settles each module's first delivery against the
-      // generation the session started from, exactly as a build does, and still
+      // while costing a full derived-input proof per delivered module. The pass
+      // lifecycle settles each module's first delivery against the generation
+      // the session started from, exactly as a build does, and still
       // revalidates a module this session already delivered. A one-shot suite
       // configures precisely this server (`vitest --run` sets `server.watch =
       // null`) and is the workload behind samchon/ttsc#970
       // (samchon/ttsc#1260). The neighbouring watch-registration decision reads
       // the same two properties for the same reason.
+      //
+      // Opening a pass no longer discards the generation, so the `else` branch
+      // is what every host with a repeating `buildStart` takes without paying a
+      // whole-project transform per rebuild (samchon/ttsc#1300).
       if (viteCommand === "serve" && viteWatching) {
         resetTtscTransformCache(transformCache);
       } else {
@@ -194,6 +302,11 @@ export type {
   TtscTransformHooks,
   TtscWatchInputEvidence,
 } from "./transform";
+export type { ITtscProjectMembershipPolicy } from "./tsconfigPaths";
+export {
+  mergeMembershipPolicyOverlay,
+  readProjectMembershipPolicy,
+} from "./tsconfigPaths";
 export {
   beginTtscTransformBuild,
   collectExternalInputHashes,
@@ -209,10 +322,15 @@ export {
 export default unplugin;
 
 /**
- * Returns `true` when the module id refers to a real TypeScript/JavaScript
- * source file that should be processed by the ttsc transform.
+ * Returns `true` when the module id refers to a real TypeScript source file
+ * that should be processed by the ttsc transform.
+ *
+ * TypeScript only. {@link sourceFilePattern} deliberately excludes JavaScript,
+ * so a `.js` module reaches no adapter's transform, and this docstring used to
+ * say otherwise while the pattern it is built from said the truth
+ * (samchon/ttsc#1309).
  *
- * Excluded ids: virtual modules (NUL prefix), `.d.ts` declaration files, and
+ * Also excluded: virtual modules (NUL prefix), `.d.ts` declaration files, and
  * anything inside `node_modules`.
  */
 export function isTransformTarget(id: string): boolean {