vitest 0.0.109 → 0.0.110

package/dist/{index-a727b58c.js → index-b183bb20.js}

@@ -7242,23 +7242,27 @@ const spinnerMap = /* @__PURE__ */ new WeakMap();
 const outputMap = /* @__PURE__ */ new WeakMap();
 const pointer = c.yellow(F_POINTER);
 const skipped = c.yellow(F_DOWN);
-function divider(text, left, right) {
+function getCols(delta = 0) {
   let length = process.stdout.columns;
   if (!length || isNaN(length))
-    length = 10;
+    length = 30;
+  return Math.max(length + delta, 0);
+}
+function divider(text, left, right) {
+  const cols = getCols();
   if (text) {
     const textLength = stripAnsi(text).length;
     if (left == null && right != null) {
-      left = length - textLength - right;
+      left = cols - textLength - right;
     } else {
-      left = left ?? Math.floor((length - textLength) / 2);
-      right = length - textLength - left;
+      left = left ?? Math.floor((cols - textLength) / 2);
+      right = cols - textLength - left;
     }
     left = Math.max(0, left);
     right = Math.max(0, right);
     return `${F_LONG_DASH.repeat(left)}${text}${F_LONG_DASH.repeat(right)}`;
   }
-  return F_LONG_DASH.repeat(length);
+  return F_LONG_DASH.repeat(cols);
 }
 function formatTestPath(root, path) {
   var _a;
@@ -7344,6 +7348,15 @@ function getStateSymbol(task) {
   }
   return " ";
 }
+function formatFilepath(path) {
+  const lastSlash = Math.max(path.lastIndexOf("/") + 1, 0);
+  const basename2 = path.slice(lastSlash);
+  let firstDot = basename2.indexOf(".");
+  if (firstDot < 0)
+    firstDot = basename2.length;
+  firstDot += lastSlash;
+  return c.dim(path.slice(0, lastSlash)) + path.slice(lastSlash, firstDot) + c.dim(path.slice(firstDot));
+}
 function renderTree(tasks, level = 0) {
   var _a, _b, _c, _d;
   let output = [];
@@ -7359,7 +7372,10 @@ function renderTree(tasks, level = 0) {
       if (duration > DURATION_LONG)
         suffix += c.yellow(` ${Math.round(duration)}${c.dim("ms")}`);
     }
-    output.push("  ".repeat(level) + prefix + task.name + suffix);
+    let name = task.name;
+    if (level === 0)
+      name = formatFilepath(name);
+    output.push("  ".repeat(level) + prefix + name + suffix);
     if (((_b = task.result) == null ? void 0 : _b.state) !== "pass" && outputMap.get(task) != null) {
       let data = outputMap.get(task);
       if (typeof data === "string") {
@@ -7369,7 +7385,7 @@ function renderTree(tasks, level = 0) {
       }
       if (data != null) {
         const out = `${"  ".repeat(level)}${F_RIGHT} ${data}`;
-        output.push(`   ${c.gray(cliTruncate(out, process.stdout.columns - 3))}`);
+        output.push(`   ${c.gray(cliTruncate(out, getCols(-3)))}`);
       }
     }
     if ((((_c = task.result) == null ? void 0 : _c.state) === "fail" || ((_d = task.result) == null ? void 0 : _d.state) === "run") && task.type === "suite" && task.tasks.length > 0)
@@ -8642,16 +8658,68 @@ MagicString.prototype.trimStart = function trimStart (charType) {
 	return this;
 };
 
-const mockRegexp = /\b(?:vitest|vi)\s*.\s*(mock|unmock|importActual|importMock)\(["`'\s](.*[@\w_-]+)["`'\s]\);?/mg;
+const mockRegexp = /\b((?:vitest|vi)\s*.\s*mock\(["`'\s](.*[@\w_-]+)["`'\s])[),]{1}/;
+const pathRegexp = /\b(?:vitest|vi)\s*.\s*(unmock|importActual|importMock)\(["`'\s](.*[@\w_-]+)["`'\s]\);?/mg;
+const isComment = (line) => {
+  const commentStarts = ["//", "/*", "*"];
+  line = line.trim();
+  return commentStarts.some((cmt) => line.startsWith(cmt));
+};
+const parseMocks = (code) => {
+  const splitted = code.split("\n");
+  const mockCalls = {};
+  let mockCall = 0;
+  let lineIndex = -1;
+  while (lineIndex < splitted.length) {
+    lineIndex++;
+    const line = splitted[lineIndex];
+    if (!line)
+      break;
+    const mock = mockCalls[mockCall] || {
+      code: "",
+      declaraton: "",
+      path: ""
+    };
+    if (!mock.code) {
+      const started = mockRegexp.exec(line);
+      if (!started || isComment(line))
+        continue;
+      mock.code += `${line}
+`;
+      mock.declaraton = started[1];
+      mock.path = started[2];
+      mockCalls[mockCall] = mock;
+      if (line.includes(");")) {
+        mockCall++;
+        continue;
+      }
+      continue;
+    }
+    mock.code += `${line}
+`;
+    mockCalls[mockCall] = mock;
+    const startNumber = (mock.code.match(/{/g) || []).length;
+    const endNumber = (mock.code.match(/}/g) || []).length;
+    if (line.includes(");")) {
+      if (startNumber === endNumber || startNumber === 0 && endNumber === 0)
+        mockCall++;
+    }
+  }
+  return Object.values(mockCalls);
+};
+const getMethodCall = (method, actualPath, importPath) => {
+  let nodeModule = "null";
+  if (actualPath.includes("/node_modules/"))
+    nodeModule = `"${importPath}"`;
+  return `__vitest__${method}__("${actualPath}", ${nodeModule}`;
+};
 const MocksPlugin = () => {
   return {
     name: "vitest:mock-plugin",
     enforce: "post",
     async transform(code, id) {
       let m;
-      const matchAll = Array.from(code.matchAll(mockRegexp));
-      if (!matchAll.length)
-        return;
+      const matchAll = code.matchAll(pathRegexp);
       for (const match of matchAll) {
         const [line, method, modulePath] = match;
         const filepath = await this.resolve(modulePath, id);
@@ -8659,18 +8727,19 @@ const MocksPlugin = () => {
           m ?? (m = new MagicString(code));
           const start = match.index || 0;
           const end = start + line.length;
-          let nodeModule = "null";
-          if (filepath.id.includes("/node_modules/"))
-            nodeModule = `"${modulePath}"`;
-          const overwrite = `__vitest__${method}__("${filepath.id}", ${nodeModule});`;
-          if (method === "mock") {
-            m.prepend(`${overwrite}
-
-`);
-            m.remove(start, end);
-          } else {
-            m.overwrite(start, end, overwrite);
-          }
+          const overwrite = `${getMethodCall(method, filepath.id, modulePath)});`;
+          m.overwrite(start, end, overwrite);
+        }
+      }
+      if (mockRegexp.exec(code)) {
+        const mocks = parseMocks((m == null ? void 0 : m.toString()) || code);
+        for (const mock of mocks) {
+          const filepath = await this.resolve(mock.path, id);
+          if (!filepath)
+            continue;
+          m ?? (m = new MagicString(code));
+          const overwrite = getMethodCall("mock", filepath.id, mock.path);
+          m.prepend(mock.code.replace(mock.declaraton, overwrite));
         }
       }
       if (m) {

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { Formatter } from 'picocolors/types';
 import { OptionsReceived } from 'pretty-format';
 import { MessagePort } from 'worker_threads';
-export { assert, default as chai, expect, should } from 'chai';
 export { Spy, SpyFn } from 'tinyspy';
+export { assert, default as chai, should } from 'chai';
 
 declare const EXPECTED_COLOR: Formatter;
 declare const RECEIVED_COLOR: Formatter;
@@ -117,6 +117,7 @@ interface AsymmetricMatcherInterface {
 declare abstract class AsymmetricMatcher<T, State extends MatcherState = MatcherState> implements AsymmetricMatcherInterface {
     protected sample: T;
     protected inverse: boolean;
+    $$typeof: symbol;
     constructor(sample: T, inverse?: boolean);
     protected getMatcherContext(): State;
     abstract asymmetricMatch(other: unknown): boolean;
@@ -528,6 +529,8 @@ declare const afterAll: (fn: SuiteHooks['afterAll'][0], timeout?: number | undef
 declare const beforeEach: (fn: SuiteHooks['beforeEach'][0], timeout?: number | undefined) => void;
 declare const afterEach: (fn: SuiteHooks['afterEach'][0], timeout?: number | undefined) => void;
 
+declare const expect: (value: any, message?: string | undefined) => Chai.Assertion;
+
 interface MockResultReturn<T> {
     type: 'return';
     value: T;
@@ -620,10 +623,60 @@ declare class VitestUtils {
     getMockedDate(): string | number | Date | null;
     spyOn: typeof spyOn;
     fn: typeof fn;
-    mock(path: string): void;
+    /**
+     * Makes all `imports` to passed module to be mocked.
+     * - If there is a factory, will return it's result. The call to `vi.mock` is hoisted to the top of the file,
+     * so you don't have access to variables declared in the global file scope, if you didn't put them before imports!
+     * - If `__mocks__` folder with file of the same name exist, all imports will
+     * return it.
+     * - If there is no `__mocks__` folder or a file with the same name inside, will call original
+     * module and mock it.
+     * @param path Path to the module. Can be aliased, if your config suppors it
+     * @param factory Factory for the mocked module. Has the highest priority.
+     */
+    mock(path: string, factory?: () => any): void;
+    /**
+     * Removes module from mocked registry. All subsequent calls to import will
+     * return original module even if it was mocked.
+     * @param path Path to the module. Can be aliased, if your config suppors it
+     */
     unmock(path: string): void;
+    /**
+     * Imports module, bypassing all checks if it should be mocked.
+     * Can be useful if you want to mock module partially.
+     * @example
+     * vi.mock('./example', async () => {
+     *  const axios = await vi.importActual('./example')
+     *
+     *  return { ...axios, get: vi.fn() }
+     * })
+     * @param path Path to the module. Can be aliased, if your config suppors it
+     * @returns Actual module without spies
+     */
     importActual<T>(path: string): Promise<T>;
-    importMock<T>(path: string): Promise<T>;
+    /**
+     * Imports a module with all of its properties and nested properties mocked.
+     * For the rules applied, see docs.
+     * @param path Path to the module. Can be aliased, if your config suppors it
+     * @returns Fully mocked module
+     */
+    importMock<T>(path: string): Promise<MaybeMockedDeep<T>>;
+    /**
+     * Type helpers for TypeScript. In reality just returns the object that was passed.
+     * @example
+     * import example from './example'
+     * vi.mock('./example')
+     *
+     * test('1+1 equals 2' async () => {
+     *  vi.mocked(example.calc).mockRestore()
+     *
+     *  const res = example.calc(1, '+', 1)
+     *
+     *  expect(res).toBe(2)
+     * })
+     * @param item Anything that can be mocked
+     * @param deep If the object is deeply mocked
+     */
     mocked<T>(item: T, deep?: false): MaybeMocked<T>;
     mocked<T>(item: T, deep: true): MaybeMockedDeep<T>;
     isMockFunction(fn: any): any;
@@ -654,6 +707,7 @@ declare global {
             any(constructor: unknown): Any;
             arrayContaining(expected: any): ArrayContaining;
             stringMatching(expected: RegExp): StringMatching;
+            assertions(expected: number): void;
         }
         interface Assertion {
             chaiEqual(expected: any): void;
@@ -708,4 +762,4 @@ declare global {
     }
 }
 
-export { ArgumentsOf, ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, ComputeMode, ConstructorArgumentsOf, DoneCallback, Environment, EnvironmentReturn, File, HookListener, InlineConfig, JestMockCompat, JestMockCompatContext, JestMockCompatFn, MaybeMocked, MaybeMockedConstructor, MaybeMockedDeep, MethodKeysOf, MockWithArgs, MockableFunction, MockedFunction, MockedFunctionDeep, MockedObject, MockedObjectDeep, ModuleCache, Nullable, PropertyKeysOf, Reporter, ResolvedConfig, RpcCall, RpcMap, RpcPayload, RpcSend, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, Suite, SuiteCollector, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestCollector, TestFactory, TestFunction, UncheckedSnapshot, UserConfig, UserConsoleLog, WorkerContext, afterAll, afterEach, beforeAll, beforeEach, describe, fn, it, spies, spyOn, suite, test, vi, vitest };
+export { ArgumentsOf, ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, ComputeMode, ConstructorArgumentsOf, DoneCallback, Environment, EnvironmentReturn, File, HookListener, InlineConfig, JestMockCompat, JestMockCompatContext, JestMockCompatFn, MaybeMocked, MaybeMockedConstructor, MaybeMockedDeep, MethodKeysOf, MockWithArgs, MockableFunction, MockedFunction, MockedFunctionDeep, MockedObject, MockedObjectDeep, ModuleCache, Nullable, PropertyKeysOf, Reporter, ResolvedConfig, RpcCall, RpcMap, RpcPayload, RpcSend, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, Suite, SuiteCollector, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestCollector, TestFactory, TestFunction, UncheckedSnapshot, UserConfig, UserConsoleLog, WorkerContext, afterAll, afterEach, beforeAll, beforeEach, describe, expect, fn, it, spies, spyOn, suite, test, vi, vitest };

package/dist/index.js

@@ -1,7 +1,7 @@
-export { d as describe, i as it, s as suite, t as test, b as vi, v as vitest } from './vi-9754296d.js';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach } from './index-0961cf69.js';
-export { assert, default as chai, expect, should } from 'chai';
-export { f as fn, s as spies, a as spyOn } from './jest-mock-8498c46d.js';
+export { d as describe, i as it, c as suite, t as test, e as vi, v as vitest } from './vi-aedc8539.js';
+export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, e as expect } from './index-a90f376d.js';
+export { f as fn, s as spies, a as spyOn } from './jest-mock-a57b745c.js';
+export { assert, default as chai, should } from 'chai';
 import './utils-d97bd6d9.js';
 import 'tty';
 import 'local-pkg';

package/dist/{jest-mock-8498c46d.js → jest-mock-a57b745c.js}

@@ -44,10 +44,7 @@ function enhanceSpy(spy) {
     }
   };
   let onceImplementations = [];
-  let name = "";
-  Object.defineProperty(stub, "name", {
-    get: () => name
-  });
+  let name = stub.name;
   stub.getMockName = () => name || "vi.fn()";
   stub.mockName = (n) => {
     name = n;

package/dist/node.js

@@ -1,4 +1,4 @@
-export { c as createVitest } from './index-a727b58c.js';
+export { c as createVitest } from './index-b183bb20.js';
 import './utils-d97bd6d9.js';
 import 'tty';
 import 'local-pkg';