vitest 0.0.112 → 0.0.116

package/dist/entry.js

@@ -1,19 +1,21 @@
 import fs, { promises } from 'fs';
-import { f as equals, h as iterableEquality, j as subsetEquality, k as isA, J as JestChaiExpect, l as clearContext, m as defaultSuite, n as setHooks, o as getHooks, p as context, s as setState, q as getFn, b as getState, e as vi } from './vi-cb9e4e4e.js';
+import { f as equals, h as iterableEquality, j as subsetEquality, k as isA, J as JestChaiExpect, l as clearContext, m as defaultSuite, n as setHooks, o as getHooks, p as context, s as setState, q as getFn, b as getState, e as vi } from './vi-b3412f83.js';
 import { Console } from 'console';
 import { Writable } from 'stream';
 import { importModule } from 'local-pkg';
 import chai$1, { expect, util } from 'chai';
 import { a as commonjsRequire, c as commonjsGlobal } from './_commonjsHelpers-c9e3b764.js';
-import { l as index, o as getNames, c as c$1, t as toArray, r as relative, p as interpretOnlyMode, q as partitionSuiteChildren, u as hasTests, j as hasFailed } from './utils-cb6b1266.js';
-import { r as rpc, s as send } from './rpc-7de86f29.js';
-import { u as unifiedDiff } from './diff-66d6bb83.js';
+import { q as index, s as slash, u as getNames, c as c$1, t as toArray, r as relative, v as interpretOnlyMode, w as partitionSuiteChildren, x as hasTests, h as hasFailed } from './index-bf29f0e6.js';
+import { r as rpc } from './rpc-8c7cc374.js';
+import { l as getOriginalPos, m as posToNumber, n as parseStack, u as unifiedDiff } from './diff-80c47cfa.js';
 import { performance } from 'perf_hooks';
-import { n as nanoid } from './jest-mock-a57b745c.js';
+import { createHash } from 'crypto';
 import { format as format$1 } from 'util';
+import './jest-mock-4a754991.js';
+import 'tinyspy';
+import 'url';
 import 'tty';
 import 'path';
-import 'tinyspy';
 
 var node = {
   name: "node",
@@ -382,6 +384,47 @@ var chaiSubset = {exports: {}};
 
 var Subset = chaiSubset.exports;
 
+async function saveInlineSnapshots(snapshots) {
+  const MagicString = (await import('./magic-string.es-94000aea.js')).default;
+  const files = new Set(snapshots.map((i) => i.file));
+  await Promise.all(Array.from(files).map(async (file) => {
+    const map = await rpc().getSourceMap(file);
+    const snaps = snapshots.filter((i) => i.file === file);
+    const code = await promises.readFile(file, "utf8");
+    const s = new MagicString(code);
+    for (const snap of snaps) {
+      const pos = await getOriginalPos(map, snap);
+      const index = posToNumber(code, pos);
+      replaceInlineSnap(code, s, index, snap.snapshot);
+    }
+    const transformed = s.toString();
+    if (transformed !== code)
+      await promises.writeFile(file, transformed, "utf-8");
+  }));
+}
+const startRegex = /toMatchInlineSnapshot\s*\(\s*(['"`\)])/m;
+function replaceInlineSnap(code, s, index, newSnap, indent = "") {
+  const startMatch = startRegex.exec(code.slice(index));
+  if (!startMatch)
+    return false;
+  newSnap = newSnap.replace(/\\/g, "\\\\").split("\n").map((i) => (indent + i).trimEnd()).join("\n");
+  const isOneline = !newSnap.includes("\n");
+  const snapString = isOneline ? `'${newSnap.replace(/'/g, "\\'").trim()}'` : `\`${newSnap.replace(/`/g, "\\`").trimEnd()}\``;
+  const quote = startMatch[1];
+  const startIndex = index + startMatch.index + startMatch[0].length;
+  if (quote === ")") {
+    s.appendRight(startIndex - 1, snapString);
+    return true;
+  }
+  const quoteEndRE = new RegExp(`(?:^|[^\\\\])${quote}`);
+  const endMatch = quoteEndRE.exec(code.slice(startIndex));
+  if (!endMatch)
+    return false;
+  const endIndex = startIndex + endMatch.index + endMatch[0].length;
+  s.overwrite(startIndex - 1, endIndex, snapString);
+  return true;
+}
+
 var naturalCompare$2 = {exports: {}};
 
 /*
@@ -2830,13 +2873,13 @@ function ensureDirectoryExists(filePath) {
 function normalizeNewlines(string) {
   return string.replace(/\r\n|\r/g, "\n");
 }
-function saveSnapshotFile(snapshotData, snapshotPath) {
+async function saveSnapshotFile(snapshotData, snapshotPath) {
   const snapshots = Object.keys(snapshotData).sort(naturalCompare$1).map((key) => `exports[${printBacktickString(key)}] = ${printBacktickString(normalizeNewlines(snapshotData[key]))};`);
   ensureDirectoryExists(snapshotPath);
-  fs.writeFileSync(snapshotPath, `${writeSnapshotVersion()}
+  await promises.writeFile(snapshotPath, `${writeSnapshotVersion()}
 
 ${snapshots.join("\n\n")}
-`);
+`, "utf-8");
 }
 
 var __defProp$1 = Object.defineProperty;
@@ -2862,6 +2905,7 @@ class SnapshotState {
     this._initialData = data;
     this._snapshotData = data;
     this._dirty = dirty;
+    this._inlineSnapshots = [];
     this._uncheckedKeys = new Set(Object.keys(this._snapshotData));
     this._counters = /* @__PURE__ */ new Map();
     this._index = 0;
@@ -2883,7 +2927,20 @@ class SnapshotState {
   }
   _addSnapshot(key, receivedSerialized, options) {
     this._dirty = true;
-    this._snapshotData[key] = receivedSerialized;
+    if (options.isInline) {
+      const error = options.error || new Error("Unknown error");
+      const stacks = parseStack(error.stack || "");
+      stacks.forEach((i) => i.file = slash(i.file));
+      const stack = stacks.find((i) => process.__vitest_worker__.ctx.files.includes(i.file));
+      if (!stack) {
+        throw new Error("Vitest: Couldn't infer stack frame for inline snapshot.");
+      }
+      this._inlineSnapshots.push(__spreadValues$1({
+        snapshot: receivedSerialized
+      }, stack));
+    } else {
+      this._snapshotData[key] = receivedSerialized;
+    }
   }
   clear() {
     this._snapshotData = this._initialData;
@@ -2894,16 +2951,19 @@ class SnapshotState {
     this.unmatched = 0;
     this.updated = 0;
   }
-  save() {
+  async save() {
     const hasExternalSnapshots = Object.keys(this._snapshotData).length;
-    const isEmpty = !hasExternalSnapshots;
+    const hasInlineSnapshots = this._inlineSnapshots.length;
+    const isEmpty = !hasExternalSnapshots && !hasInlineSnapshots;
     const status = {
       deleted: false,
       saved: false
     };
     if ((this._dirty || this._uncheckedKeys.size) && !isEmpty) {
       if (hasExternalSnapshots)
-        saveSnapshotFile(this._snapshotData, this._snapshotPath);
+        await saveSnapshotFile(this._snapshotData, this._snapshotPath);
+      if (hasInlineSnapshots)
+        await saveInlineSnapshots(this._inlineSnapshots);
       status.saved = true;
     } else if (!hasExternalSnapshots && fs.existsSync(this._snapshotPath)) {
       if (this._updateSnapshot === "all")
@@ -3019,7 +3079,7 @@ class SnapshotClient {
   clearTest() {
     this.test = void 0;
   }
-  assert(received, message, inlineSnapshot) {
+  assert(received, message, isInline = false, inlineSnapshot) {
     if (!this.test)
       throw new Error("Snapshot cannot be used outside of test");
     const testName = [
@@ -3029,7 +3089,7 @@ class SnapshotClient {
     const { actual, expected, key, pass } = this.snapshotState.match({
       testName,
       received,
-      isInline: !!inlineSnapshot,
+      isInline,
       inlineSnapshot: inlineSnapshot == null ? void 0 : inlineSnapshot.trim()
     });
     if (!pass) {
@@ -3044,13 +3104,13 @@ class SnapshotClient {
   async saveSnap() {
     if (!this.testFile || !this.snapshotState)
       return;
-    const result = packSnapshotState(this.testFile, this.snapshotState);
-    await rpc("snapshotSaved", result);
+    const result = await packSnapshotState(this.testFile, this.snapshotState);
+    await rpc().snapshotSaved(result);
     this.testFile = "";
     this.snapshotState = void 0;
   }
 }
-function packSnapshotState(filepath, state) {
+async function packSnapshotState(filepath, state) {
   const snapshot = {
     filepath,
     added: 0,
@@ -3065,7 +3125,7 @@ function packSnapshotState(filepath, state) {
   const uncheckedKeys = state.getUncheckedKeys();
   if (uncheckedCount)
     state.removeUncheckedKeys();
-  const status = state.save();
+  const status = await state.save();
   snapshot.fileDeleted = status.deleted;
   snapshot.added = state.added;
   snapshot.matched = state.matched;
@@ -3091,7 +3151,7 @@ const SnapshotPlugin = (chai, utils) => {
   }
   utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function(inlineSnapshot, message) {
     const expected = utils.flag(this, "object");
-    getSnapshotClient().assert(expected, message, inlineSnapshot);
+    getSnapshotClient().assert(expected, message, true, inlineSnapshot);
   });
 };
 
@@ -3472,13 +3532,13 @@ async function setupGlobalEnv(config) {
   setupConsoleLogSpy();
   await setupChai();
   if (config.global)
-    (await import('./global-201fd559.js')).registerApiGlobally();
+    (await import('./global-a73dfade.js')).registerApiGlobally();
 }
 function setupConsoleLogSpy() {
   const stdout = new Writable({
     write(data, encoding, callback) {
       var _a;
-      send("log", {
+      rpc().onUserLog({
         type: "stdout",
         content: String(data),
         taskId: (_a = process.__vitest_worker__.current) == null ? void 0 : _a.id
@@ -3489,7 +3549,7 @@ function setupConsoleLogSpy() {
   const stderr = new Writable({
     write(data, encoding, callback) {
       var _a;
-      send("log", {
+      rpc().onUserLog({
         type: "stderr",
         content: String(data),
         taskId: (_a = process.__vitest_worker__.current) == null ? void 0 : _a.id
@@ -3520,21 +3580,24 @@ async function runSetupFiles(config) {
   }));
 }
 
-function serializeError(val) {
+function serializeError(val, seen = /* @__PURE__ */ new WeakSet()) {
   if (!val || typeof val === "string")
     return val;
   if (typeof val === "function")
     return `Function<${val.name}>`;
   if (typeof val !== "object")
     return val;
-  if (val instanceof Promise || "then" in val)
+  if (val instanceof Promise || "then" in val || val.constructor && val.constructor.prototype === "AsyncFunction")
     return "Promise";
   if (typeof Element !== "undefined" && val instanceof Element)
     return val.tagName;
   if (typeof val.asymmetricMatch === "function")
     return `${val.toString()} ${format$1(val.sample)}`;
+  if (seen.has(val))
+    return val;
+  seen.add(val);
   Object.keys(val).forEach((key) => {
-    val[key] = serializeError(val[key]);
+    val[key] = serializeError(val[key], seen);
   });
   return val;
 }
@@ -3552,12 +3615,16 @@ function processError(err) {
   return serializeError(err);
 }
 
+function hash(str, length = 10) {
+  return createHash("md5").update(str).digest("hex").slice(0, length);
+}
 async function collectTests(paths, config) {
   const files = [];
   for (const filepath of paths) {
+    const path = relative(config.root, filepath);
     const file = {
-      id: nanoid(),
-      name: relative(config.root, filepath),
+      id: hash(path),
+      name: path,
       type: "suite",
       mode: "run",
       computeMode: "serial",
@@ -3589,12 +3656,20 @@ async function collectTests(paths, config) {
       };
       process.stdout.write("\0");
     }
+    calculateHash(file);
     files.push(file);
   }
   const tasks = files.reduce((tasks2, file) => tasks2.concat(file.tasks), []);
   interpretOnlyMode(tasks);
   return files;
 }
+function calculateHash(parent) {
+  parent.tasks.forEach((t, idx) => {
+    t.id = `${parent.id}_${idx}`;
+    if (t.type === "suite")
+      calculateHash(t);
+  });
+}
 
 async function callSuiteHook(suite, name, args) {
   if (name === "beforeEach" && suite.suite)
@@ -3603,8 +3678,24 @@ async function callSuiteHook(suite, name, args) {
   if (name === "afterEach" && suite.suite)
     await callSuiteHook(suite.suite, name, args);
 }
+const packs = [];
+let updateTimer;
+let previousUpdate;
 function updateTask(task) {
-  return rpc("onTaskUpdate", [task.id, task.result]);
+  packs.push([task.id, task.result]);
+  clearTimeout(updateTimer);
+  updateTimer = setTimeout(() => {
+    previousUpdate = sendTasksUpdate();
+  }, 10);
+}
+async function sendTasksUpdate() {
+  clearTimeout(updateTimer);
+  await previousUpdate;
+  if (packs.length) {
+    const p = rpc().onTaskUpdate(packs);
+    packs.length = 0;
+    return p;
+  }
 }
 async function runTest(test) {
   if (test.mode !== "run")
@@ -3703,9 +3794,10 @@ async function runSuites(suites) {
 }
 async function startTests(paths, config) {
   const files = await collectTests(paths, config);
-  send("onCollected", files);
+  rpc().onCollected(files);
   await runSuites(files);
   await getSnapshotClient().saveSnap();
+  await sendTasksUpdate();
 }
 function clearModuleMocks() {
   const { clearMocks, mockReset, restoreMocks } = process.__vitest_worker__.config;

package/dist/{global-201fd559.js → global-a73dfade.js}

@@ -1,15 +1,15 @@
-import { g as globalApis } from './constants-2b0310b7.js';
-import { i as index } from './index-2bb9fd4d.js';
+import { g as globalApis } from './constants-080f26e8.js';
+import { i as index } from './index-80d9a771.js';
 import 'url';
-import './utils-cb6b1266.js';
+import './index-bf29f0e6.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
-import './vi-cb9e4e4e.js';
-import './jest-mock-a57b745c.js';
+import './vi-b3412f83.js';
+import './_commonjsHelpers-c9e3b764.js';
+import './jest-mock-4a754991.js';
 import 'chai';
 import 'tinyspy';
-import './_commonjsHelpers-c9e3b764.js';
 
 function registerApiGlobally() {
   globalApis.forEach((api) => {