@uiverify/vitest 1.0.2 → 1.2.0

package/dist/browser-setup.js

@@ -1,11 +1,34 @@
 import {
   autoSnapshot,
-  beginTest
-} from "./chunk-W4AFNW3N.js";
+  beginTest,
+  preloadFonts
+} from "./chunk-ZJM4XSRA.js";
 
 // src/browser-setup.ts
 import { afterEach, beforeEach, inject } from "vitest";
+
+// src/seed.ts
+var INITIAL_SEED = 2685821657736338400;
+var seed = INITIAL_SEED;
+var installed = false;
+function seededRandom() {
+  seed ^= seed << 13;
+  seed ^= seed >> 7;
+  seed ^= seed << 17;
+  return (seed >>> 0) % 1e9 / 1e9;
+}
+function installSeededRandom() {
+  if (installed) return;
+  installed = true;
+  Math.random = seededRandom;
+}
+function resetSeed() {
+  if (installed) seed = INITIAL_SEED;
+}
+
+// src/browser-setup.ts
 Reflect.set(globalThis, "__UI_VERIFY__", true);
+installSeededRandom();
 function globalAutoDisabled() {
   try {
     return Boolean(inject("__uiverify")?.disableAutoSnapshot);
@@ -13,7 +36,9 @@ function globalAutoDisabled() {
     return false;
   }
 }
-beforeEach((ctx) => {
+beforeEach(async (ctx) => {
+  resetSeed();
+  await preloadFonts();
   beginTest(ctx.task);
 });
 afterEach(async (ctx) => {

package/dist/{chunk-W4AFNW3N.js → chunk-ZJM4XSRA.js}

@@ -1,3 +1,34 @@
+// src/settle.ts
+var SETTLE_TIMEOUT_MS = 3e3;
+var realSetTimeout = typeof setTimeout === "function" ? setTimeout.bind(globalThis) : () => 0;
+function timeout(ms) {
+  return new Promise((resolve) => realSetTimeout(() => resolve(), ms));
+}
+function cap(work) {
+  return Promise.race([work, timeout(SETTLE_TIMEOUT_MS)]);
+}
+async function preloadFonts() {
+  if (typeof document === "undefined" || !document.fonts) return;
+  const loadAll = Promise.all(Array.from(document.fonts, (f) => f.load().catch(() => void 0)));
+  await cap(loadAll.then(() => document.fonts.ready));
+}
+async function settle() {
+  if (typeof document === "undefined") return;
+  await preloadFonts();
+  const pending = Array.from(document.images).filter((img) => !img.complete);
+  if (!pending.length) return;
+  await cap(
+    Promise.all(
+      pending.map(
+        (img) => new Promise((resolve) => {
+          img.addEventListener("load", () => resolve(), { once: true });
+          img.addEventListener("error", () => resolve(), { once: true });
+        })
+      )
+    )
+  );
+}
+
 // src/capture.ts
 import { commands } from "@vitest/browser/context";
 import { snapshot } from "rrweb-snapshot";
@@ -26,7 +57,7 @@ function snapshotIds(task, name) {
 // package.json
 var package_default = {
   name: "@uiverify/vitest",
-  version: "1.0.2",
+  version: "1.2.0",
   description: "Vitest browser-mode capture SDK for UI Verify (uiverify.ai): add uiverifyPlugin() to your Vitest config and each browser-mode test archives its final DOM (serialized DOM + resource bytes) to be replayed + visually diffed by UI Verify. Produces an archive the uiverify CLI uploads; talks to nothing at runtime.",
   keywords: [
     "visual-testing",
@@ -144,6 +175,7 @@ async function collectResources() {
 }
 async function capture(task, name) {
   const { id, title } = snapshotIds(task, name);
+  await settle();
   const serialize = (recordCanvas) => snapshot(document, { inlineStylesheet: true, recordCanvas, slimDOM: { script: true } });
   let dom;
   try {
@@ -164,7 +196,11 @@ async function capture(task, name) {
     colorScheme,
     dom,
     resources,
-    producer: PRODUCER
+    producer: PRODUCER,
+    // The test file (project-root-relative), so UI Verify can locate this snapshot in the module graph
+    // for skip-unchanged. `task.file.name` is already root-relative — the same value snapshot ids derive
+    // their first segment from — so it lines up with the graph names the reporter emits.
+    ...task.file?.name ? { sourcePath: task.file.name } : {}
   };
   await commands.__uiverifyWriteSnapshot(archived);
   return id;
@@ -197,6 +233,7 @@ async function autoSnapshot(passed) {
 }
 
 export {
+  preloadFonts,
   beginTest,
   takeSnapshot,
   disableAutoSnapshot,

package/dist/index.d.ts

@@ -6,4 +6,9 @@ declare function takeSnapshot(name?: string): Promise<string>;
 /** Turn off the automatic end-of-test snapshot for the current test only. */
 declare function disableAutoSnapshot(): void;
 
-export { disableAutoSnapshot, takeSnapshot };
+/** Load every registered `@font-face` and wait for the font set to be ready. Exported so a test can call
+ *  it BEFORE `render()` for a component that measures text width on mount - a mid-load font bakes a wrong
+ *  metric (a 1px-shifted layout) that settling AFTER render can no longer undo. */
+declare function preloadFonts(): Promise<void>;
+
+export { disableAutoSnapshot, preloadFonts, takeSnapshot };

package/dist/index.js

@@ -1,8 +1,10 @@
 import {
   disableAutoSnapshot,
+  preloadFonts,
   takeSnapshot
-} from "./chunk-W4AFNW3N.js";
+} from "./chunk-ZJM4XSRA.js";
 export {
   disableAutoSnapshot,
+  preloadFonts,
   takeSnapshot
 };

package/dist/plugin.js

@@ -31,6 +31,115 @@ function writeSnapshot(outDir, snapshot) {
 import fs2 from "fs";
 import path3 from "path";
 
+// src/graph-reporter.ts
+import fs3 from "fs";
+import path5 from "path";
+
+// src/preview-stats.ts
+import path4 from "path";
+function toRepoRel(viteRoot, raw) {
+  if (!raw) return null;
+  const p = raw.replace(/\?.*$/, "");
+  if (p.includes("\0") || p.startsWith("virtual:")) return null;
+  if (!path4.isAbsolute(p)) return null;
+  if (/(^|[/\\])node_modules[/\\]/.test(p)) return null;
+  return path4.relative(viteRoot, p).split(path4.sep).join("/");
+}
+function buildPreviewStats(input) {
+  const reasonsByName = /* @__PURE__ */ new Map();
+  const ensure = (name) => {
+    let set = reasonsByName.get(name);
+    if (!set) reasonsByName.set(name, set = /* @__PURE__ */ new Set());
+    return set;
+  };
+  for (const mod of input.modules) {
+    const name = toRepoRel(input.viteRoot, mod.file ?? mod.id);
+    if (name === null) continue;
+    const reasons = ensure(name);
+    for (const imp of mod.importers ?? []) {
+      const r = toRepoRel(input.viteRoot, imp.file ?? imp.id);
+      if (r !== null && r !== name) reasons.add(r);
+    }
+  }
+  const testNames = input.testFiles.map((f) => toRepoRel(input.viteRoot, f)).filter((n) => n !== null);
+  for (const sf of input.setupFiles) {
+    const name = toRepoRel(input.viteRoot, sf);
+    if (name === null) continue;
+    const reasons = ensure(name);
+    for (const t of testNames) if (t !== name) reasons.add(t);
+  }
+  return {
+    modules: [...reasonsByName].map(([name, reasons]) => ({
+      name,
+      reasons: [...reasons].map((moduleName) => ({ moduleName }))
+    }))
+  };
+}
+
+// src/graph-reporter.ts
+function collectModules(map, out) {
+  if (typeof map?.forEach !== "function") return;
+  map.forEach((mod) => out.push(mod));
+}
+function buildStatsFromRun(vitest, testModules) {
+  const projects = vitest?.projects ?? [];
+  if (projects.length === 0) return null;
+  const testFilesByProject = /* @__PURE__ */ new Map();
+  for (const tm of testModules ?? []) {
+    if (!tm.project || !tm.moduleId) continue;
+    const arr = testFilesByProject.get(tm.project) ?? [];
+    arr.push(tm.moduleId);
+    testFilesByProject.set(tm.project, arr);
+  }
+  const reasonsByName = /* @__PURE__ */ new Map();
+  let any = false;
+  for (const project of projects) {
+    const vite = project.browser?.vite;
+    const viteRoot = vite?.config?.root;
+    if (!vite || !viteRoot) continue;
+    const modules = [];
+    collectModules((vite.environments?.client?.moduleGraph ?? vite.moduleGraph)?.idToModuleMap, modules);
+    if (modules.length === 0) continue;
+    const testFiles = [.../* @__PURE__ */ new Set([...testFilesByProject.get(project) ?? [], ...project.testFilesList ?? []])];
+    const stats = buildPreviewStats({ viteRoot, modules, setupFiles: project.config?.setupFiles ?? [], testFiles });
+    for (const m of stats.modules) {
+      let set = reasonsByName.get(m.name);
+      if (!set) reasonsByName.set(m.name, set = /* @__PURE__ */ new Set());
+      for (const r of m.reasons) set.add(r.moduleName);
+    }
+    any = true;
+  }
+  if (!any) return null;
+  return {
+    modules: [...reasonsByName].map(([name, reasons]) => ({
+      name,
+      reasons: [...reasons].map((moduleName) => ({ moduleName }))
+    }))
+  };
+}
+function emitModuleGraph(outDir, vitest, testModules) {
+  const stats = buildStatsFromRun(vitest, testModules);
+  if (!stats) return false;
+  fs3.mkdirSync(outDir, { recursive: true });
+  fs3.writeFileSync(path5.join(outDir, "preview-stats.json"), JSON.stringify(stats));
+  return true;
+}
+function graphReporter(outDir) {
+  let vitest;
+  return {
+    onInit(ctx) {
+      vitest = ctx;
+    },
+    onTestRunEnd(testModules) {
+      try {
+        emitModuleGraph(outDir, vitest, testModules);
+      } catch (err) {
+        console.warn("[uiverify] could not emit the module graph for --only-changed:", err);
+      }
+    }
+  };
+}
+
 // src/plugin.ts
 var SETUP_MODULE = "@uiverify/vitest/browser-setup";
 function uiverifyPlugin(options = {}) {
@@ -44,6 +153,11 @@ function uiverifyPlugin(options = {}) {
     optimizeDeps: { exclude: ["@uiverify/vitest"] },
     test: {
       setupFiles: [SETUP_MODULE],
+      // Emit Vite's module graph as `preview-stats.json` so `uiverify upload --only-changed` can skip
+      // unchanged snapshots. `"default"` is kept so the plugin doesn't silence Vitest's own output. If a
+      // user's own `reporters` config ends up displacing this, the only effect is that no graph ships and
+      // the server safely renders everything — add `graphReporter()` back to keep the skip savings.
+      reporters: ["default", graphReporter(outDir)],
       provide: { __uiverify: { disableAutoSnapshot: options.disableAutoSnapshot ?? false } },
       browser: {
         commands: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uiverify/vitest",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "Vitest browser-mode capture SDK for UI Verify (uiverify.ai): add uiverifyPlugin() to your Vitest config and each browser-mode test archives its final DOM (serialized DOM + resource bytes) to be replayed + visually diffed by UI Verify. Produces an archive the uiverify CLI uploads; talks to nothing at runtime.",
   "keywords": [
     "visual-testing",