vitest 0.0.112 → 0.0.113

package/dist/entry.js

@@ -1,18 +1,19 @@
 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-51946984.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 { c as index, r as relative } from './index-1488b423.js';
 import { r as rpc, s as send } from './rpc-7de86f29.js';
-import { u as unifiedDiff } from './diff-66d6bb83.js';
+import { s as slash, f as getNames, c as c$1, t as toArray, i as interpretOnlyMode, p as partitionSuiteChildren, j as hasTests, h as hasFailed } from './index-041e627e.js';
+import { l as getOriginalPos, m as posToNumber, n as parseStack, u as unifiedDiff } from './diff-9c43ab50.js';
 import { performance } from 'perf_hooks';
 import { n as nanoid } from './jest-mock-a57b745c.js';
 import { format as format$1 } from 'util';
-import 'tty';
 import 'path';
+import 'tty';
 import 'tinyspy';
 
 var node = {
@@ -382,6 +383,44 @@ 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, true);
+    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);
+    }
+    await promises.writeFile(file, s.toString(), "utf-8");
+  }));
+}
+const startRegex = /toMatchInlineSnapshot\s*\(\s*(['"`\)])/m;
+function replaceInlineSnap(code, s, index, newSnap) {
+  const startMatch = startRegex.exec(code.slice(index));
+  if (!startMatch)
+    return false;
+  newSnap = newSnap.replace(/\\/g, "\\\\");
+  const snapString = newSnap.includes("\n") ? `\`${newSnap.replace(/`/g, "\\`").trimEnd()}\`` : `'${newSnap.replace(/'/g, "\\'")}'`;
+  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 +2869,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 +2901,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 +2923,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 +2947,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 +3075,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 +3085,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 +3100,13 @@ class SnapshotClient {
   async saveSnap() {
     if (!this.testFile || !this.snapshotState)
       return;
-    const result = packSnapshotState(this.testFile, this.snapshotState);
+    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 +3121,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 +3147,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,7 +3528,7 @@ async function setupGlobalEnv(config) {
   setupConsoleLogSpy();
   await setupChai();
   if (config.global)
-    (await import('./global-201fd559.js')).registerApiGlobally();
+    (await import('./global-75208c77.js')).registerApiGlobally();
 }
 function setupConsoleLogSpy() {
   const stdout = new Writable({

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

@@ -1,14 +1,15 @@
-import { g as globalApis } from './constants-2b0310b7.js';
-import { i as index } from './index-2bb9fd4d.js';
+import { g as globalApis } from './constants-900abe4a.js';
+import { i as index } from './index-09437c50.js';
 import 'url';
-import './utils-cb6b1266.js';
-import 'tty';
-import 'local-pkg';
+import './index-1488b423.js';
 import 'path';
-import './vi-cb9e4e4e.js';
+import './vi-51946984.js';
 import './jest-mock-a57b745c.js';
 import 'chai';
 import 'tinyspy';
+import './index-041e627e.js';
+import 'tty';
+import 'local-pkg';
 import './_commonjsHelpers-c9e3b764.js';
 
 function registerApiGlobally() {

package/dist/{utils-cb6b1266.js → index-041e627e.js}

@@ -1,6 +1,5 @@
 import require$$0 from 'tty';
 import { isPackageExists } from 'local-pkg';
-import path from 'path';
 
 var picocolors = {exports: {}};
 
@@ -65,189 +64,6 @@ picocolors.exports.createColors = createColors;
 
 var c = picocolors.exports;
 
-function normalizeWindowsPath(input = "") {
-  if (!input.includes("\\")) {
-    return input;
-  }
-  return input.replace(/\\/g, "/");
-}
-
-const _UNC_REGEX = /^[/][/]/;
-const _UNC_DRIVE_REGEX = /^[/][/]([.]{1,2}[/])?([a-zA-Z]):[/]/;
-const _IS_ABSOLUTE_RE = /^\/|^\\|^[a-zA-Z]:[/\\]/;
-const sep = "/";
-const delimiter = ":";
-const normalize = function(path2) {
-  if (path2.length === 0) {
-    return ".";
-  }
-  path2 = normalizeWindowsPath(path2);
-  const isUNCPath = path2.match(_UNC_REGEX);
-  const hasUNCDrive = isUNCPath && path2.match(_UNC_DRIVE_REGEX);
-  const isPathAbsolute = isAbsolute(path2);
-  const trailingSeparator = path2[path2.length - 1] === "/";
-  path2 = normalizeString(path2, !isPathAbsolute);
-  if (path2.length === 0) {
-    if (isPathAbsolute) {
-      return "/";
-    }
-    return trailingSeparator ? "./" : ".";
-  }
-  if (trailingSeparator) {
-    path2 += "/";
-  }
-  if (isUNCPath) {
-    if (hasUNCDrive) {
-      return `//./${path2}`;
-    }
-    return `//${path2}`;
-  }
-  return isPathAbsolute && !isAbsolute(path2) ? `/${path2}` : path2;
-};
-const join = function(...args) {
-  if (args.length === 0) {
-    return ".";
-  }
-  let joined;
-  for (let i = 0; i < args.length; ++i) {
-    const arg = args[i];
-    if (arg.length > 0) {
-      if (joined === void 0) {
-        joined = arg;
-      } else {
-        joined += `/${arg}`;
-      }
-    }
-  }
-  if (joined === void 0) {
-    return ".";
-  }
-  return normalize(joined);
-};
-const resolve = function(...args) {
-  args = args.map((arg) => normalizeWindowsPath(arg));
-  let resolvedPath = "";
-  let resolvedAbsolute = false;
-  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-    const path2 = i >= 0 ? args[i] : process.cwd();
-    if (path2.length === 0) {
-      continue;
-    }
-    resolvedPath = `${path2}/${resolvedPath}`;
-    resolvedAbsolute = isAbsolute(path2);
-  }
-  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
-    return `/${resolvedPath}`;
-  }
-  return resolvedPath.length > 0 ? resolvedPath : ".";
-};
-function normalizeString(path2, allowAboveRoot) {
-  let res = "";
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let char = null;
-  for (let i = 0; i <= path2.length; ++i) {
-    if (i < path2.length) {
-      char = path2[i];
-    } else if (char === "/") {
-      break;
-    } else {
-      char = "/";
-    }
-    if (char === "/") {
-      if (lastSlash === i - 1 || dots === 1) ; else if (dots === 2) {
-        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
-          if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf("/");
-            if (lastSlashIndex === -1) {
-              res = "";
-              lastSegmentLength = 0;
-            } else {
-              res = res.slice(0, lastSlashIndex);
-              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-            }
-            lastSlash = i;
-            dots = 0;
-            continue;
-          } else if (res.length !== 0) {
-            res = "";
-            lastSegmentLength = 0;
-            lastSlash = i;
-            dots = 0;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          res += res.length > 0 ? "/.." : "..";
-          lastSegmentLength = 2;
-        }
-      } else {
-        if (res.length > 0) {
-          res += `/${path2.slice(lastSlash + 1, i)}`;
-        } else {
-          res = path2.slice(lastSlash + 1, i);
-        }
-        lastSegmentLength = i - lastSlash - 1;
-      }
-      lastSlash = i;
-      dots = 0;
-    } else if (char === "." && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
-    }
-  }
-  return res;
-}
-const isAbsolute = function(p) {
-  return _IS_ABSOLUTE_RE.test(p);
-};
-const toNamespacedPath = function(p) {
-  return normalizeWindowsPath(p);
-};
-const extname = function(p) {
-  return path.posix.extname(normalizeWindowsPath(p));
-};
-const relative = function(from, to) {
-  return path.posix.relative(normalizeWindowsPath(from), normalizeWindowsPath(to));
-};
-const dirname = function(p) {
-  return path.posix.dirname(normalizeWindowsPath(p));
-};
-const format = function(p) {
-  return normalizeWindowsPath(path.posix.format(p));
-};
-const basename = function(p, ext) {
-  return path.posix.basename(normalizeWindowsPath(p), ext);
-};
-const parse = function(p) {
-  return path.posix.parse(normalizeWindowsPath(p));
-};
-
-const _path = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  sep: sep,
-  delimiter: delimiter,
-  normalize: normalize,
-  join: join,
-  resolve: resolve,
-  normalizeString: normalizeString,
-  isAbsolute: isAbsolute,
-  toNamespacedPath: toNamespacedPath,
-  extname: extname,
-  relative: relative,
-  dirname: dirname,
-  format: format,
-  basename: basename,
-  parse: parse
-});
-
-const index = {
-  ..._path
-};
-
 function toArray(array) {
   array = array || [];
   if (Array.isArray(array))
@@ -349,4 +165,4 @@ async function ensurePackageInstalled(dependency, promptInstall = !process.env.C
   return false;
 }
 
-export { getTests as a, basename as b, c, dirname as d, ensurePackageInstalled as e, getSuites as f, getFullName as g, resolve as h, isAbsolute as i, hasFailed as j, notNullish as k, index as l, mergeSlashes as m, noop as n, getNames as o, interpretOnlyMode as p, partitionSuiteChildren as q, relative as r, slash as s, toArray as t, hasTests as u, getTasks as v };
+export { getSuites as a, getTests as b, c, notNullish as d, ensurePackageInstalled as e, getNames as f, getFullName as g, hasFailed as h, interpretOnlyMode as i, hasTests as j, getTasks as k, mergeSlashes as m, noop as n, partitionSuiteChildren as p, slash as s, toArray as t };

package/dist/{index-2bb9fd4d.js → index-09437c50.js}

@@ -1,4 +1,4 @@
-import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, b as getState, s as setState, c as suite, t as test, d as describe, i as it, v as vitest, e as vi } from './vi-cb9e4e4e.js';
+import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, b as getState, s as setState, c as suite, t as test, d as describe, i as it, v as vitest, e as vi } from './vi-51946984.js';
 import chai, { assert, should } from 'chai';
 import { s as spies, a as spyOn, f as fn } from './jest-mock-a57b745c.js';
 

package/dist/index-1488b423.js

@@ -0,0 +1,186 @@
+import path from 'path';
+
+function normalizeWindowsPath(input = "") {
+  if (!input.includes("\\")) {
+    return input;
+  }
+  return input.replace(/\\/g, "/");
+}
+
+const _UNC_REGEX = /^[/][/]/;
+const _UNC_DRIVE_REGEX = /^[/][/]([.]{1,2}[/])?([a-zA-Z]):[/]/;
+const _IS_ABSOLUTE_RE = /^\/|^\\|^[a-zA-Z]:[/\\]/;
+const sep = "/";
+const delimiter = ":";
+const normalize = function(path2) {
+  if (path2.length === 0) {
+    return ".";
+  }
+  path2 = normalizeWindowsPath(path2);
+  const isUNCPath = path2.match(_UNC_REGEX);
+  const hasUNCDrive = isUNCPath && path2.match(_UNC_DRIVE_REGEX);
+  const isPathAbsolute = isAbsolute(path2);
+  const trailingSeparator = path2[path2.length - 1] === "/";
+  path2 = normalizeString(path2, !isPathAbsolute);
+  if (path2.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path2 += "/";
+  }
+  if (isUNCPath) {
+    if (hasUNCDrive) {
+      return `//./${path2}`;
+    }
+    return `//${path2}`;
+  }
+  return isPathAbsolute && !isAbsolute(path2) ? `/${path2}` : path2;
+};
+const join = function(...args) {
+  if (args.length === 0) {
+    return ".";
+  }
+  let joined;
+  for (let i = 0; i < args.length; ++i) {
+    const arg = args[i];
+    if (arg.length > 0) {
+      if (joined === void 0) {
+        joined = arg;
+      } else {
+        joined += `/${arg}`;
+      }
+    }
+  }
+  if (joined === void 0) {
+    return ".";
+  }
+  return normalize(joined);
+};
+const resolve = function(...args) {
+  args = args.map((arg) => normalizeWindowsPath(arg));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    const path2 = i >= 0 ? args[i] : process.cwd();
+    if (path2.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path2}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path2);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path2, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let i = 0; i <= path2.length; ++i) {
+    if (i < path2.length) {
+      char = path2[i];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === i - 1 || dots === 1) ; else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = i;
+            dots = 0;
+            continue;
+          } else if (res.length !== 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path2.slice(lastSlash + 1, i)}`;
+        } else {
+          res = path2.slice(lastSlash + 1, i);
+        }
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+const toNamespacedPath = function(p) {
+  return normalizeWindowsPath(p);
+};
+const extname = function(p) {
+  return path.posix.extname(normalizeWindowsPath(p));
+};
+const relative = function(from, to) {
+  return path.posix.relative(normalizeWindowsPath(from), normalizeWindowsPath(to));
+};
+const dirname = function(p) {
+  return path.posix.dirname(normalizeWindowsPath(p));
+};
+const format = function(p) {
+  return normalizeWindowsPath(path.posix.format(p));
+};
+const basename = function(p, ext) {
+  return path.posix.basename(normalizeWindowsPath(p), ext);
+};
+const parse = function(p) {
+  return path.posix.parse(normalizeWindowsPath(p));
+};
+
+const _path = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  sep: sep,
+  delimiter: delimiter,
+  normalize: normalize,
+  join: join,
+  resolve: resolve,
+  normalizeString: normalizeString,
+  isAbsolute: isAbsolute,
+  toNamespacedPath: toNamespacedPath,
+  extname: extname,
+  relative: relative,
+  dirname: dirname,
+  format: format,
+  basename: basename,
+  parse: parse
+});
+
+const index = {
+  ..._path
+};
+
+export { resolve as a, basename as b, index as c, dirname as d, isAbsolute as i, relative as r };