vitest 0.0.122 → 0.0.126

package/dist/{setup-c9c7cb5b.js → setup-b0d2ca33.js}

@@ -9,11 +9,16 @@ import require$$2 from 'events';
 import require$$1 from 'https';
 import require$$2$1 from 'http';
 import require$$7 from 'url';
-import { A as API_PATH } from './constants-22bbd600.js';
-import './index-090545ef.js';
+import { A as API_PATH } from './constants-8b3a9b31.js';
+import { s as shouldExternalize } from './externalize-2f63779d.js';
+import { o as interpretSourcePos, n as parseStacktrace } from './diff-3adb959a.js';
+import './index-9fdde2e8.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
+import 'module';
+import 'assert';
+import 'util';
 
 /*! (c) 2020 Andrea Giammarchi */
 
@@ -4266,9 +4271,12 @@ function setup(ctx) {
         getFiles() {
           return ctx.state.getFiles();
         },
-        getSourceCode(id) {
+        readFile(id) {
           return promises.readFile(id, "utf-8");
         },
+        writeFile(id, content) {
+          return promises.writeFile(id, content, "utf-8");
+        },
         async rerun(files) {
           await ctx.report("onWatcherRerun", files);
           await ctx.runFiles(files);
@@ -4276,6 +4284,35 @@ function setup(ctx) {
         },
         getConfig() {
           return ctx.config;
+        },
+        async getModuleGraph(id) {
+          const graph = {};
+          function clearId(id2) {
+            return (id2 == null ? void 0 : id2.replace(/\?v=\w+$/, "")) || "";
+          }
+          function get(mod, seen = new Set()) {
+            if (!mod || !mod.id || seen.has(mod))
+              return;
+            seen.add(mod);
+            const mods = Array.from(mod.importedModules).filter((i) => i.id && !i.id.includes("/vitest/dist/"));
+            graph[clearId(mod.id)] = mods.map((i) => clearId(i.id));
+            mods.forEach((m) => get(m, seen));
+          }
+          get(ctx.server.moduleGraph.getModuleById(id));
+          const externalized = [];
+          const inlined = [];
+          await Promise.all(Object.keys(graph).map(async (i) => {
+            const rewrote = await shouldExternalize(i, ctx.config);
+            if (rewrote)
+              externalized.push(rewrote);
+            else
+              inlined.push(i);
+          }));
+          return {
+            graph,
+            externalized,
+            inlined
+          };
         }
       },
       post(msg) {
@@ -4302,12 +4339,21 @@ class WebSocketReporter {
     this.clients = clients;
   }
   onCollected(files) {
+    if (this.clients.size === 0)
+      return;
     this.clients.forEach((client) => {
       var _a;
       (_a = client.onCollected) == null ? void 0 : _a.call(client, files);
     });
   }
-  onTaskUpdate(packs) {
+  async onTaskUpdate(packs) {
+    if (this.clients.size === 0)
+      return;
+    await Promise.all(packs.map(async (i) => {
+      var _a;
+      if ((_a = i[1]) == null ? void 0 : _a.error)
+        await interpretSourcePos(parseStacktrace(i[1].error), this.ctx);
+    }));
     this.clients.forEach((client) => {
       var _a;
       (_a = client.onTaskUpdate) == null ? void 0 : _a.call(client, packs);

package/dist/{vi-c99184a5.js → vi-5ff3926d.js}

@@ -1,6 +1,6 @@
-import { n as noop, i as isObject } from './index-090545ef.js';
+import { n as noop, i as isObject } from './index-9fdde2e8.js';
+import { i as isMockFunction, a as spyOn, f as fn, s as spies } from './jest-mock-30625866.js';
 import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers-c9e3b764.js';
-import { a as spyOn, f as fn, s as spies } from './jest-mock-038a01b3.js';
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -125,23 +125,23 @@ function createSuiteHooks() {
   };
 }
 function createSuiteCollector(name, factory = () => {
-}, mode, suiteComputeMode) {
+}, mode, concurrent) {
   const tasks = [];
   const factoryQueue = [];
   let suite2;
   initSuite();
   const test2 = createChainable(["concurrent", "skip", "only", "todo", "fails"], function(name2, fn, timeout) {
     const mode2 = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
-    const computeMode = this.concurrent ? "concurrent" : void 0;
     const test3 = {
       id: "",
       type: "test",
       name: name2,
       mode: mode2,
-      computeMode: computeMode ?? (suiteComputeMode ?? "serial"),
       suite: void 0,
       fails: this.fails
     };
+    if (this.concurrent || concurrent)
+      test3.concurrent = true;
     setFn(test3, normalizeTest(fn || noop, timeout));
     tasks.push(test3);
   });
@@ -162,7 +162,6 @@ function createSuiteCollector(name, factory = () => {
     suite2 = {
       id: "",
       type: "suite",
-      computeMode: "serial",
       name,
       mode,
       tasks: []
@@ -194,8 +193,7 @@ function createSuiteCollector(name, factory = () => {
 function createSuite() {
   return createChainable(["concurrent", "skip", "only", "todo"], function(name, factory) {
     const mode = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
-    const computeMode = this.concurrent ? "concurrent" : void 0;
-    return createSuiteCollector(name, factory, mode, computeMode);
+    return createSuiteCollector(name, factory, mode, this.concurrent);
   });
 }
 
@@ -2863,12 +2861,7 @@ const JestChaiExpect = (chai, utils) => {
   def("toContainEqual", function(expected) {
     const obj = utils.flag(this, "object");
     const index = Array.from(obj).findIndex((item) => {
-      try {
-        chai.assert.deepEqual(item, expected);
-      } catch {
-        return false;
-      }
-      return true;
+      return equals(item, expected);
     });
     this.assert(index !== -1, "expected #{this} to deep equally contain #{exp}", "expected #{this} to not deep equally contain #{exp}", expected);
   });
@@ -2917,15 +2910,24 @@ const JestChaiExpect = (chai, utils) => {
   def("toHaveProperty", function(...args) {
     return this.have.deep.nested.property(...args);
   });
-  def("toBeCloseTo", function(number, numDigits = 2) {
-    utils.expectTypes(this, ["number"]);
-    return this.closeTo(number, numDigits);
+  def("toBeCloseTo", function(received, precision = 2) {
+    const expected = this._obj;
+    let pass = false;
+    let expectedDiff = 0;
+    let receivedDiff = 0;
+    if (received === Infinity && expected === Infinity) {
+      pass = true;
+    } else if (received === -Infinity && expected === -Infinity) {
+      pass = true;
+    } else {
+      expectedDiff = Math.pow(10, -precision) / 2;
+      receivedDiff = Math.abs(expected - received);
+      pass = receivedDiff < expectedDiff;
+    }
+    return this.assert(pass, `expected #{this} to be close to #{exp}, recieved difference is ${receivedDiff}, but expected ${expectedDiff}`, `expected #{this} to not be close to #{exp}, recieved difference is ${receivedDiff}, but expected ${expectedDiff}`, received, expected);
   });
-  function isSpy(putativeSpy) {
-    return typeof putativeSpy === "function" && "__isSpy" in putativeSpy && putativeSpy.__isSpy;
-  }
   const assertIsMock = (assertion) => {
-    if (!isSpy(assertion._obj))
+    if (!isMockFunction(assertion._obj))
       throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
   };
   const getSpy = (assertion) => {
@@ -2935,23 +2937,26 @@ const JestChaiExpect = (chai, utils) => {
   def(["toHaveBeenCalledTimes", "toBeCalledTimes"], function(number) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
-    return this.assert(spy.callCount === number, `expected "${spyName}" to be called #{exp} times`, `expected "${spyName}" to not be called #{exp} times`, number, spy.callCount);
+    const callCount = spy.mock.calls.length;
+    return this.assert(callCount === number, `expected "${spyName}" to be called #{exp} times`, `expected "${spyName}" to not be called #{exp} times`, number, callCount);
   });
   def("toHaveBeenCalledOnce", function() {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
-    return this.assert(spy.callCount === 1, `expected "${spyName}" to be called once`, `expected "${spyName}" to not be called once`, 1, spy.callCount);
+    const callCount = spy.mock.calls.length;
+    return this.assert(callCount === 1, `expected "${spyName}" to be called once`, `expected "${spyName}" to not be called once`, 1, callCount);
   });
   def(["toHaveBeenCalled", "toBeCalled"], function() {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
-    return this.assert(spy.called, `expected "${spyName}" to be called at least once`, `expected "${spyName}" to not be called at all`, true, spy.called);
+    const called = spy.mock.calls.length > 0;
+    return this.assert(called, `expected "${spyName}" to be called at least once`, `expected "${spyName}" to not be called at all`, true, called);
   });
   def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
-    const pass = spy.calls.some((callArg) => equals(callArg, args, [iterableEquality]));
-    return this.assert(pass, `expected "${spyName}" to be called with arguments: #{exp}`, `expected "${spyName}" to not be called with arguments: #{exp}`, args, spy.calls);
+    const pass = spy.mock.calls.some((callArg) => equals(callArg, args, [iterableEquality]));
+    return this.assert(pass, `expected "${spyName}" to be called with arguments: #{exp}`, `expected "${spyName}" to not be called with arguments: #{exp}`, args, spy.mock.calls);
   });
   const ordinalOf = (i) => {
     const j = i % 10;
@@ -2967,44 +2972,40 @@ const JestChaiExpect = (chai, utils) => {
   def(["toHaveBeenNthCalledWith", "nthCalledWith"], function(times, ...args) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
-    const nthCall = spy.calls[times - 1];
+    const nthCall = spy.mock.calls[times - 1];
     this.assert(equals(nthCall, args, [iterableEquality]), `expected ${ordinalOf(times)} "${spyName}" call to have been called with #{exp}`, `expected ${ordinalOf(times)} "${spyName}" call to not have been called with #{exp}`, args, nthCall);
   });
   def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
-    const lastCall = spy.calls[spy.calls.length - 1];
+    const lastCall = spy.mock.calls[spy.calls.length - 1];
     this.assert(equals(lastCall, args, [iterableEquality]), `expected last "${spyName}" call to have been called with #{exp}`, `expected last "${spyName}" call to not have been called with #{exp}`, args, lastCall);
   });
   def(["toThrow", "toThrowError"], function(expected) {
-    const negate = utils.flag(this, "negate");
-    if (negate)
-      this.not.to.throw(expected);
-    else
-      this.to.throw(expected);
+    return this.to.throw(expected);
   });
   def(["toHaveReturned", "toReturn"], function() {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
-    const calledAndNotThrew = spy.called && !spy.results.some(([type]) => type === "error");
+    const calledAndNotThrew = spy.mock.calls.length > 0 && !spy.mock.results.some(({ type }) => type === "throw");
     this.assert(calledAndNotThrew, `expected "${spyName}" to be successfully called at least once`, `expected "${spyName}" to not be successfully called`, calledAndNotThrew, !calledAndNotThrew);
   });
   def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
-    const successfullReturns = spy.results.reduce((success, [type]) => type === "error" ? success : ++success, 0);
+    const successfullReturns = spy.mock.results.reduce((success, { type }) => type === "throw" ? success : ++success, 0);
     this.assert(successfullReturns === times, `expected "${spyName}" to be successfully called ${times} times`, `expected "${spyName}" to not be successfully called ${times} times`, `expected number of returns: ${times}`, `received number of returns: ${successfullReturns}`);
   });
   def(["toHaveReturnedWith", "toReturnWith"], function(value) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
-    const pass = spy.results.some(([type, result]) => type === "ok" && equals(value, result));
+    const pass = spy.mock.results.some(({ type, value: result }) => type === "return" && equals(value, result));
     this.assert(pass, `expected "${spyName}" to be successfully called with #{exp}`, `expected "${spyName}" to not be successfully called with #{exp}`, value);
   });
   def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
-    const lastResult = spy.returns[spy.returns.length - 1];
+    const { value: lastResult } = spy.mock.results[spy.returns.length - 1];
     const pass = equals(lastResult, value);
     this.assert(pass, `expected last "${spyName}" call to return #{exp}`, `expected last "${spyName}" call to not return #{exp}`, value, lastResult);
   });
@@ -3012,9 +3013,9 @@ const JestChaiExpect = (chai, utils) => {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
     const isNot = utils.flag(this, "negate");
-    const [callType, callResult] = spy.results[nthCall - 1];
+    const { type: callType, value: callResult } = spy.mock.results[nthCall - 1];
     const ordinalCall = `${ordinalOf(nthCall)} call`;
-    if (!isNot && callType === "error")
+    if (!isNot && callType === "throw")
       chai.assert.fail(`expected ${ordinalCall} to return #{exp}, but instead it threw an error`);
     const nthCallReturn = equals(callResult, value);
     this.assert(nthCallReturn, `expected ${ordinalCall} "${spyName}" call to return #{exp}`, `expected ${ordinalCall} "${spyName}" call to not return #{exp}`, value, callResult);
@@ -3364,7 +3365,7 @@ class FakeTimers {
       this._setInterval,
       this._clearTimeout,
       this._clearInterval
-    ], 'timers are not mocked. try calling "vitest.useFakeTimers()" first');
+    ], 'timers are not mocked. try calling "vi.useFakeTimers()" first');
   }
 }
 
@@ -3421,7 +3422,7 @@ class VitestUtils {
     return item;
   }
   isMockFunction(fn2) {
-    return typeof fn2 === "function" && "__isSpy" in fn2 && fn2.__isSpy;
+    return isMockFunction(fn2);
   }
   clearAllMocks() {
     __vitest__clearMocks__({ clearMocks: true });