@weasel-js/forge 1.14.1 → 1.14.2

package/dist/vite/index.d.ts

@@ -61,4 +61,21 @@ interface WatchProbeOptions {
 /** A plugin giving any dev server the warning forge's own gives when the OS reports no file changes. */
 declare function watchProbe({ probe }?: WatchProbeOptions): Plugin;
 
-export { type ForgeOptions, type ForgeTestOptions, type PropControlsOptions, type WatchProbeOptions, forge, forgeTest, watchProbe };
+/** Options for the `watchRecovery` vite plugin. */
+interface WatchRecoveryOptions {
+    /**
+     * How long the watcher must have reported nothing before the served files are checked for changes it missed,
+     * and how often they are checked while it stays quiet, in milliseconds. Default 2000.
+     */
+    quietMs?: number;
+}
+/**
+ * A plugin that serves an edit the OS never reported. Each module vite serves from a file is stamped with the file's
+ * modification time when vite reads it. A request for a module whose file has changed since, and a check of every
+ * served file once the watcher has been quiet for `quietMs`, replays the missed change through vite's watcher: the
+ * module is transformed again and the open page gets the update, or a reload, as it would have from the event.
+ * Each recovery logs one line naming the file.
+ */
+declare function watchRecovery({ quietMs }?: WatchRecoveryOptions): Plugin;
+
+export { type ForgeOptions, type ForgeTestOptions, type PropControlsOptions, type WatchProbeOptions, type WatchRecoveryOptions, forge, forgeTest, watchProbe, watchRecovery };

package/dist/vite/index.js

@@ -3,13 +3,14 @@ import { byComponent } from '../chunk-RVJHUY7W.js';
 import { isGallery } from '../chunk-VUPN73JP.js';
 import { PROP_ARG_TYPES_EXPORT, storyNameFromExport, storyId } from '../chunk-5WS67HMU.js';
 import { readFileSync, mkdtempSync, existsSync, mkdirSync, writeFileSync, globSync, statSync, watch, rmSync } from 'fs';
-import { resolve, relative, sep, join, dirname, basename, matchesGlob, posix } from 'path';
+import { resolve, relative, sep, isAbsolute, join, dirname, basename, matchesGlob, posix } from 'path';
 import { parse } from '@babel/parser';
 import { execFile } from 'child_process';
 import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
 import { stableStringify } from '@weasel-js/core/json';
 import { tmpdir } from 'os';
+import { normalizePath } from 'vite';
 
 // src/vite/html.ts
 var escaped = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -1783,6 +1784,125 @@ ${lines.join("\n")}
     "capture-frame-entry.js": () => captureFrameEntry(frameStyles())
   };
 }
+var WATCH_RECOVERY = "weasel-watch-recovery";
+var QUIET_MS = 2e3;
+var mtimeOf = (file) => {
+  try {
+    return statSync(file).mtimeMs;
+  } catch {
+    return void 0;
+  }
+};
+var withoutQuery = (url) => url.replace(/[?#].*$/s, "");
+function watchRecovery({ quietMs = QUIET_MS } = {}) {
+  const stamps = /* @__PURE__ */ new Map();
+  const read = /* @__PURE__ */ new Map();
+  const fileOfUrl = /* @__PURE__ */ new Map();
+  let server;
+  let active = false;
+  let skipped = () => true;
+  let lastEvent = 0;
+  let replaying = false;
+  let timer;
+  const restamp = (file) => {
+    const modules = stamps.get(file);
+    const now = mtimeOf(file);
+    if (!modules || now === void 0) return;
+    for (const id of modules.keys()) modules.set(id, now);
+  };
+  const missed = (file) => {
+    const modules = stamps.get(file);
+    const now = mtimeOf(file);
+    if (!modules || now === void 0) return false;
+    for (const stamp of modules.values()) if (stamp !== now) return true;
+    return false;
+  };
+  const recover = (file, outcome) => {
+    if (!server) return;
+    restamp(file);
+    for (const environment of Object.values(server.environments)) environment.moduleGraph.onFileChange(file);
+    server.config.logger.warn(`[watch] ${relative(server.config.root, file)} changed with no file event; ${outcome}`, {
+      timestamp: true
+    });
+    replaying = true;
+    try {
+      server.watcher.emit("change", file);
+    } finally {
+      replaying = false;
+    }
+  };
+  const sweep = () => {
+    if (Date.now() - lastEvent < quietMs) return;
+    for (const file of stamps.keys()) if (missed(file)) recover(file, "pushing it to the page");
+  };
+  const self = {
+    name: WATCH_RECOVERY,
+    apply: "serve",
+    configResolved(config) {
+      active = config.server.watch !== null && config.plugins.find((p) => p.name === WATCH_RECOVERY) === self;
+      const cacheDir = normalizePath(config.cacheDir) + "/";
+      skipped = (file) => !isAbsolute(file) || file.includes("/node_modules/") || file.startsWith(cacheDir);
+    },
+    configureServer(s) {
+      if (!active) return;
+      server = s;
+      for (const event of ["add", "change", "unlink"]) {
+        s.watcher.on(event, (path) => {
+          if (replaying) return;
+          lastEvent = Date.now();
+          const file = normalizePath(path);
+          if (event === "unlink") stamps.delete(file);
+          else restamp(file);
+        });
+      }
+      const base = s.config.base;
+      s.middlewares.use(function weaselWatchRecovery(req, _res, next) {
+        let url = withoutQuery(req.url ?? "");
+        if (base !== "/" && url.startsWith(base)) url = url.slice(base.length - 1);
+        let file;
+        try {
+          file = fileOfUrl.get(decodeURI(url));
+        } catch {
+        }
+        if (file && missed(file)) recover(file, "serving the new text");
+        next();
+      });
+      timer = setInterval(sweep, quietMs);
+      timer.unref();
+    },
+    load: {
+      order: "pre",
+      handler(id) {
+        if (!active || this.environment.name !== "client") return;
+        const file = withoutQuery(id);
+        if (skipped(file)) return;
+        const mtime = mtimeOf(file);
+        if (mtime !== void 0) read.set(id, mtime);
+      }
+    },
+    transform: {
+      order: "pre",
+      handler(_code, id) {
+        const mtime = read.get(id);
+        if (mtime === void 0) return;
+        read.delete(id);
+        if (this.environment.mode !== "dev") return;
+        const mod = this.environment.moduleGraph.getModuleById(id);
+        if (!mod?.file) return;
+        let modules = stamps.get(mod.file);
+        if (!modules) stamps.set(mod.file, modules = /* @__PURE__ */ new Map());
+        modules.set(id, mtime);
+        fileOfUrl.set(withoutQuery(mod.url), mod.file);
+      }
+    },
+    buildEnd() {
+      clearInterval(timer);
+    }
+  };
+  return self;
+}
+
+// src/vite/watchProbe.ts
 var WAIT_MS = 5e3;
 var REWRITE_MS = 250;
 var watchDir = (dir, onEvent) => {
@@ -1823,11 +1943,16 @@ function fileEventsArrive({ waitMs = WAIT_MS, watch = watchDir } = {}) {
     deadline.unref();
   });
 }
-var SILENT = `[watch] a file written ${WAIT_MS / 1e3} s ago has not been reported by the OS file watcher, so an edit will not reach the page until file events arrive again. \`server.watch: { usePolling: true }\` serves edits without them. On macOS, look for \`fseventsd\` held at 100% CPU.`;
+var UNREPORTED = `[watch] a file written ${WAIT_MS / 1e3} s ago has not been reported by the OS file watcher, `;
+var FSEVENTSD = "On macOS, look for `fseventsd` held at 100% CPU.";
+var SILENT = UNREPORTED + "so an edit will not reach the page until file events arrive again. `server.watch: { usePolling: true }` serves edits without them, and so does the `watchRecovery()` plugin beside `watchProbe()`. " + FSEVENTSD;
+var RECOVERING = UNREPORTED + "so edits are found by their modification times instead: on the next request for the module, or within seconds once the watcher is quiet, each logged as it is served. " + FSEVENTSD;
 async function warnWhenWatchIsSilent(server, probe = fileEventsArrive) {
   const { watch } = server.config.server;
   if (watch === null || watch?.usePolling) return;
-  if (!await probe()) server.config.logger.warn(SILENT);
+  if (await probe()) return;
+  const recovering = server.config.plugins.some((p) => p.name === WATCH_RECOVERY);
+  server.config.logger.warn(recovering ? RECOVERING : SILENT);
 }
 function watchProbe({ probe } = {}) {
   return {
@@ -1856,6 +1981,14 @@ function watchSources(server, { files, depGraph, reindex, redeps, logError }) {
     });
   }
 }
+function companions(options, storyFiles) {
+  const { storybookShims: shims, propControls: controls } = options;
+  return [
+    watchRecovery(),
+    ...shims === false ? [] : [storybookShims()],
+    ...controls === false ? [] : [propControls(storyFiles, controls === true ? void 0 : controls)]
+  ];
+}
 function forge(options) {
   let root = process.cwd();
   let base = "/";
@@ -1994,8 +2127,7 @@ function forge(options) {
     return true;
   }
   return [
-    ...options.storybookShims === false ? [] : [storybookShims()],
-    ...options.propControls === false ? [] : [propControls(() => [...files().keys()], options.propControls === true ? void 0 : options.propControls)],
+    ...companions(options, () => [...files().keys()]),
     {
       name: "weaselforge",
       config(config, { command }) {
@@ -2121,6 +2253,6 @@ ${lines.join("\n")}
   ];
 }
 
-export { forge, forgeTest, watchProbe };
+export { forge, forgeTest, watchProbe, watchRecovery };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map