@ttsc/unplugin 0.19.3 → 0.20.1

package/lib/core/viteServe.mjs

@@ -0,0 +1,178 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathIdentityKey } from './transform.mjs';
+
+/**
+ * How often each registered missing watch input is stat-polled, in
+ * milliseconds.
+ *
+ * Polling is the only watch primitive that covers the whole class: the dev
+ * server's chokidar watcher ignores every `node_modules` directory, which is
+ * exactly where superseding resolution candidates usually live, and `fs.watch`
+ * cannot observe a path whose parent directories do not exist yet. One `stat`
+ * every half second per missing path is negligible against a dev server's
+ * baseline.
+ */
+const MISSING_INPUT_POLL_INTERVAL = 500;
+/** Create an empty missing-input watch for one plugin instance. */
+function createViteServeMissingInputWatch() {
+    const entries = new Map();
+    let server;
+    const unwatch = (identity, entry) => {
+        fs.unwatchFile(entry.spelling, entry.listener);
+        entries.delete(identity);
+    };
+    return {
+        attach(next) {
+            server = next;
+        },
+        dispose() {
+            for (const [identity, entry] of entries) {
+                unwatch(identity, entry);
+            }
+            // The server reference deliberately survives: `vite.restartServer`
+            // configures the replacement server (attach) before it closes the old
+            // one (whose buildEnd runs this dispose), so unsetting it here would
+            // detach the freshly attached replacement and revive the 500 this
+            // module exists to prevent. A same-instance `vite build` after a serve
+            // is instead excluded by the adapter's `config.command` gate.
+        },
+        serving() {
+            return server !== undefined;
+        },
+        watch(input, importer) {
+            const spelling = path.resolve(input);
+            const identity = pathIdentityKey(spelling);
+            const existing = entries.get(identity);
+            if (existing !== undefined) {
+                existing.importers.add(path.resolve(importer));
+                return;
+            }
+            const entry = {
+                importers: new Set([path.resolve(importer)]),
+                listener: (current) => {
+                    // `fs.watchFile` reports a missing path as zeroed stats (and fires
+                    // once with them right after registration); only a poll that
+                    // observes a real file is a creation event.
+                    if (current.mtimeMs === 0 && !fs.existsSync(entry.spelling)) {
+                        return;
+                    }
+                    unwatch(identity, entry);
+                    if (server === undefined) {
+                        return;
+                    }
+                    invalidateImporters(server, entry.importers);
+                    sendFullReload(server);
+                },
+                spelling,
+            };
+            entries.set(identity, entry);
+            const watcher = fs.watchFile(spelling, { interval: MISSING_INPUT_POLL_INTERVAL }, entry.listener);
+            // A poller must never keep the dev-server process alive on its own.
+            watcher.unref?.();
+            // `fs.watchFile` snapshots the path's stats at registration and fires
+            // only on a subsequent change, so a file created between the adapter's
+            // existence check and this registration would count as "unchanged" and
+            // never fire. One deferred recheck closes that window; routing through
+            // the listener keeps a single finalization path.
+            const recheck = setTimeout(() => {
+                if (entries.get(identity) !== entry) {
+                    return;
+                }
+                try {
+                    entry.listener(fs.statSync(entry.spelling));
+                }
+                catch {
+                    // Still missing (or deleted again): the ordinary poll stays armed.
+                }
+            }, MISSING_INPUT_POLL_INTERVAL);
+            recheck.unref?.();
+        },
+    };
+}
+/**
+ * Invalidate every module-graph node of the registered importers so the next
+ * request retransforms them. Importers keep their original absolute spelling so
+ * the module graph's exact-key lookup can hit; graph lookups still go through
+ * {@link selectModulesByFile} because module-graph file keys are
+ * slash-normalized and, on case-insensitive filesystems, may not match the
+ * compiler's spelling byte for byte.
+ */
+function invalidateImporters(server, importers) {
+    for (const graph of selectModuleGraphs(server)) {
+        for (const importer of importers) {
+            for (const node of selectModulesByFile(graph, importer)) {
+                try {
+                    graph.invalidateModule?.(node);
+                }
+                catch {
+                    // A graph shape this structural view mispredicts must not crash the
+                    // poll; the full-reload below still forces a refetch, and the
+                    // transform cache's external-input hashes force the recompile.
+                }
+            }
+        }
+    }
+}
+/**
+ * Enumerate the server's module graphs: one per environment under the
+ * environment API (Vite 6+), otherwise the mixed module graph (Vite 5).
+ */
+function selectModuleGraphs(server) {
+    const graphs = [];
+    for (const environment of Object.values(server.environments ?? {})) {
+        if (environment?.moduleGraph !== undefined) {
+            graphs.push(environment.moduleGraph);
+        }
+    }
+    if (graphs.length === 0 && server.moduleGraph !== undefined) {
+        graphs.push(server.moduleGraph);
+    }
+    return graphs;
+}
+/**
+ * Look up the module nodes registered for one importer spelling: the fast
+ * slash-normalized `getModulesByFile` lookup first, then an identity scan of
+ * `fileToModulesMap` for spellings that differ only by separator or case.
+ */
+function selectModulesByFile(graph, importer) {
+    const direct = graph.getModulesByFile?.(importer.replace(/\\/g, "/"));
+    if (direct !== undefined && direct.size !== 0) {
+        return [...direct];
+    }
+    const identity = pathIdentityKey(importer);
+    const output = [];
+    for (const [file, nodes] of graph.fileToModulesMap ?? []) {
+        if (typeof file === "string" && pathIdentityKey(file) === identity) {
+            output.push(...nodes);
+        }
+    }
+    return output;
+}
+/**
+ * Deliver one full-reload so connected clients refetch the invalidated
+ * importers. The channels differ across Vite majors (`ws`, deprecated `hot`,
+ * per-environment `hot`); the first one that accepts the payload wins.
+ */
+function sendFullReload(server) {
+    for (const channel of [
+        server.ws,
+        server.hot,
+        server.environments?.client?.hot,
+    ]) {
+        if (channel?.send === undefined) {
+            continue;
+        }
+        try {
+            channel.send({ path: "*", type: "full-reload" });
+            return;
+        }
+        catch {
+            // Try the next channel; an unsupported payload on one major must not
+            // suppress delivery through another.
+        }
+    }
+}
+
+export { createViteServeMissingInputWatch };
+//# sourceMappingURL=viteServe.mjs.map

package/lib/core/viteServe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"viteServe.mjs","sources":["../../src/core/viteServe.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/unplugin",
-  "version": "0.19.3",
+  "version": "0.20.1",
   "description": "Bundler adapters for ttsc plugins.",
   "main": "lib/index.js",
   "module": "lib/index.mjs",
@@ -95,7 +95,7 @@
     "unplugin": "^2.3.11"
   },
   "peerDependencies": {
-    "ttsc": "0.19.3"
+    "ttsc": "^0.20.1"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.2",
@@ -108,7 +108,7 @@
     "tslib": "^2.8.1",
     "typescript": "^7.0.2",
     "vite": "^7.1.12",
-    "ttsc": "0.19.3"
+    "ttsc": "0.20.1"
   },
   "repository": {
     "type": "git",

package/src/core/index.ts

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import path from "node:path";
 import type { UnpluginFactory, UnpluginInstance } from "unplugin";
 import { createUnplugin } from "unplugin";
 
@@ -12,6 +14,7 @@ import {
   stripQuery,
   transformTtsc,
 } from "./transform";
+import { createViteServeMissingInputWatch } from "./viteServe";
 
 const name = "ttsc-unplugin";
 /**
@@ -44,7 +47,9 @@ const unpluginFactory: UnpluginFactory<
 > = (rawOptions = {}) => {
   const options = resolveOptions(rawOptions);
   const transformCache = createTtscTransformCache();
+  const missingInputs = createViteServeMissingInputWatch();
   let aliases: unknown;
+  let viteCommand: string | undefined;
 
   return {
     name,
@@ -53,6 +58,25 @@ const unpluginFactory: UnpluginFactory<
     vite: {
       configResolved(config) {
         aliases = config.resolve.alias;
+        // Re-read per config resolution: a plugin instance reused across a
+        // serve and a later build must stop routing missing inputs to the
+        // serve-time poll, even though the closed server stays attached
+        // (see the dispose note in viteServe.ts).
+        viteCommand = config.command;
+      },
+      // Vite serve funnels every transform-context `addWatchFile()` into the
+      // module's added-import graph (`_addedImports`), which import-analysis
+      // resolves like real imports. Capture the dev server so the transform
+      // hook can route watch inputs that do not exist yet — superseding
+      // resolution candidates above all — around that graph and still
+      // invalidate their importers when the path is created.
+      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.
+      buildEnd() {
+        missingInputs.dispose();
       },
     },
 
@@ -75,8 +99,23 @@ const unpluginFactory: UnpluginFactory<
         // unioned with the host-owned reference graph) so type-only inputs
         // invalidate this module in watch mode and persistent caches;
         // bundlers erase type-only imports from their own module graph and
-        // would otherwise serve stale generated code.
-        addWatchFile: (watched) => this.addWatchFile(watched),
+        // would otherwise serve stale generated code. Under Vite serve a
+        // missing input must not enter `addWatchFile`: import-analysis
+        // resolves added imports and 500s on a path that is absent by design
+        // (a superseding resolution candidate, a not-yet-generated
+        // dependency), so those are watched on the filesystem instead and
+        // invalidate this module when created.
+        addWatchFile: (watched) => {
+          if (
+            viteCommand === "serve" &&
+            missingInputs.serving() &&
+            !fs.existsSync(watched)
+          ) {
+            missingInputs.watch(watched, path.resolve(file));
+            return;
+          }
+          this.addWatchFile(watched);
+        },
         // A module the plugin declared volatile depends on non-file inputs,
         // which no file-dependency snapshot can represent; mark it
         // uncacheable where the bundler exposes that control.