vitest 0.24.4 → 0.25.0

package/dist/{chunk-runtime-hooks.66004497.js → chunk-runtime-test-state.31ce8643.js}

@@ -1,17 +1,37 @@
-import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it, b as bench, c as createExpect, e as globalExpect } from './chunk-runtime-chain.a5cd236b.js';
-import { g as getWorkerState, R as RealDate, r as resetDate, m as mockDate, a as resetModules } from './chunk-mock-date.9fe2b438.js';
-import { p as parseStacktrace } from './chunk-utils-source-map.d9d36eb0.js';
+import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it, b as bench, c as createExpect, e as globalExpect } from './chunk-runtime-chain.3b531731.js';
+import { g as getWorkerState, R as RealDate, r as resetDate, m as mockDate, a as resetModules } from './chunk-typecheck-constants.410fa7b2.js';
+import { p as parseStacktrace } from './chunk-utils-source-map.1a66263d.js';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.addc3445.js';
 import util from 'util';
 import { spyOn, fn, isMockFunction, spies } from './spy.js';
-import { s as safeSetTimeout } from './chunk-utils-timers.ab764c0c.js';
+import { s as safeSetTimeout } from './chunk-utils-timers.d1fcc6bb.js';
 import * as chai from 'chai';
 import { assert, should } from 'chai';
 
+let _test;
+function setCurrentTest(test) {
+  _test = test;
+}
+function getCurrentTest() {
+  return _test;
+}
+
 const beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
 const afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
 const beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
 const afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+const onTestFailed = createTestHook("onTestFailed", (test, handler) => {
+  test.onFailed || (test.onFailed = []);
+  test.onFailed.push(handler);
+});
+function createTestHook(name, handler) {
+  return (fn) => {
+    const current = getCurrentTest();
+    if (!current)
+      throw new Error(`Hook ${name}() can only be called inside a test`);
+    handler(current, fn);
+  };
+}
 
 function withCallback(fn) {
   return new Promise(
@@ -2804,6 +2824,83 @@ function isWatchMode() {
   return getRunningMode() === "watch";
 }
 
+var dist = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.expectTypeOf = void 0;
+	const fn = () => true;
+	/**
+	 * Similar to Jest's `expect`, but with type-awareness.
+	 * Gives you access to a number of type-matchers that let you make assertions about the
+	 * form of a reference or generic type parameter.
+	 *
+	 * @example
+	 * import {foo, bar} from '../foo'
+	 * import {expectTypeOf} from 'expect-type'
+	 *
+	 * test('foo types', () => {
+	 *   // make sure `foo` has type {a: number}
+	 *   expectTypeOf(foo).toMatchTypeOf({a: 1})
+	 *   expectTypeOf(foo).toHaveProperty('a').toBeNumber()
+	 *
+	 *   // make sure `bar` is a function taking a string:
+	 *   expectTypeOf(bar).parameter(0).toBeString()
+	 *   expectTypeOf(bar).returns.not.toBeAny()
+	 * })
+	 *
+	 * @description
+	 * See the [full docs](https://npmjs.com/package/expect-type#documentation) for lots more examples.
+	 */
+	const expectTypeOf = (_actual) => {
+	    const nonFunctionProperties = [
+	        'parameters',
+	        'returns',
+	        'resolves',
+	        'not',
+	        'items',
+	        'constructorParameters',
+	        'instance',
+	        'guards',
+	        'asserts',
+	    ];
+	    const obj = {
+	        /* eslint-disable mmkal/@typescript-eslint/no-unsafe-assignment */
+	        toBeAny: fn,
+	        toBeUnknown: fn,
+	        toBeNever: fn,
+	        toBeFunction: fn,
+	        toBeObject: fn,
+	        toBeArray: fn,
+	        toBeString: fn,
+	        toBeNumber: fn,
+	        toBeBoolean: fn,
+	        toBeVoid: fn,
+	        toBeSymbol: fn,
+	        toBeNull: fn,
+	        toBeUndefined: fn,
+	        toBeNullable: fn,
+	        toMatchTypeOf: fn,
+	        toEqualTypeOf: fn,
+	        toBeCallableWith: fn,
+	        toBeConstructibleWith: fn,
+	        /* eslint-enable mmkal/@typescript-eslint/no-unsafe-assignment */
+	        extract: exports.expectTypeOf,
+	        exclude: exports.expectTypeOf,
+	        toHaveProperty: exports.expectTypeOf,
+	        parameter: exports.expectTypeOf,
+	    };
+	    const getterProperties = nonFunctionProperties;
+	    getterProperties.forEach((prop) => Object.defineProperty(obj, prop, { get: () => (0, exports.expectTypeOf)({}) }));
+	    return obj;
+	};
+	exports.expectTypeOf = expectTypeOf;
+} (dist));
+
+const noop = () => {
+};
+const assertType = noop;
+
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
   suite: suite,
@@ -2817,6 +2914,7 @@ var index = /*#__PURE__*/Object.freeze({
   afterAll: afterAll,
   beforeEach: beforeEach,
   afterEach: afterEach,
+  onTestFailed: onTestFailed,
   withCallback: withCallback,
   assert: assert,
   should: should,
@@ -2826,7 +2924,9 @@ var index = /*#__PURE__*/Object.freeze({
   vitest: vitest,
   vi: vi,
   getRunningMode: getRunningMode,
-  isWatchMode: isWatchMode
+  isWatchMode: isWatchMode,
+  expectTypeOf: dist.expectTypeOf,
+  assertType: assertType
 });
 
-export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, runOnce as e, isFirstRun as f, vitest as g, getRunningMode as h, index as i, isWatchMode as j, resetRunOnceCounter as r, vi as v, withCallback as w };
+export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, dist as e, assertType as f, runOnce as g, isFirstRun as h, index as i, vitest as j, getRunningMode as k, isWatchMode as l, onTestFailed as o, resetRunOnceCounter as r, setCurrentTest as s, vi as v, withCallback as w };

package/dist/{chunk-mock-date.9fe2b438.js → chunk-typecheck-constants.410fa7b2.js}

@@ -1,7 +1,9 @@
 import { relative } from 'path';
-import { i as isNode, a as isBrowser, r as relative$1, p as picocolors, E as EXIT_CODE_RESTART } from './chunk-utils-env.b1281522.js';
+import { i as isNode, a as isBrowser, r as relative$1, p as picocolors, E as EXIT_CODE_RESTART } from './chunk-utils-env.7fe285cc.js';
 import { isPackageExists } from 'local-pkg';
 
+const TYPECHECK_SUITE = Symbol("vitest:typecheck-suite");
+
 const RealDate = Date;
 let now = null;
 class MockDate extends RealDate {
@@ -179,11 +181,21 @@ function shuffle(array, seed = RealDate.now()) {
 }
 
 function isAtomTest(s) {
-  return s.type === "test" || s.type === "benchmark";
+  return s.type === "test" || s.type === "benchmark" || s.type === "typecheck";
 }
 function getTests(suite) {
   return toArray(suite).flatMap((s) => isAtomTest(s) ? [s] : s.tasks.flatMap((c) => isAtomTest(c) ? [c] : getTests(c)));
 }
+function isTypecheckTest(suite) {
+  return TYPECHECK_SUITE in suite;
+}
+function getTypecheckTests(suite) {
+  return toArray(suite).flatMap((s) => {
+    if (s.type !== "suite")
+      return [];
+    return TYPECHECK_SUITE in s ? [s, ...getTypecheckTests(s.tasks)] : getTypecheckTests(s.tasks);
+  });
+}
 function getSuites(suite) {
   return toArray(suite).flatMap((s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []);
 }
@@ -254,6 +266,13 @@ function resetModules(modules, resetMocks = false) {
 function getFullName(task) {
   return getNames(task).join(picocolors.exports.dim(" > "));
 }
+function removeUndefinedValues(obj) {
+  for (const key in Object.keys(obj)) {
+    if (obj[key] === void 0)
+      delete obj[key];
+  }
+  return obj;
+}
 async function ensurePackageInstalled(dependency, root) {
   if (isPackageExists(dependency, { paths: [root] }))
     return true;
@@ -270,7 +289,7 @@ async function ensurePackageInstalled(dependency, root) {
     message: picocolors.exports.reset(`Do you want to install ${picocolors.exports.green(dependency)}?`)
   });
   if (install) {
-    await (await import('./chunk-install-pkg.22707ee4.js')).installPackage(dependency, { dev: true });
+    await (await import('./chunk-install-pkg.55bfe508.js')).installPackage(dependency, { dev: true });
     process.stderr.write(picocolors.exports.yellow(`
 Package ${dependency} installed, re-run the command to start.
 `));
@@ -326,4 +345,4 @@ function createDefer() {
   return p;
 }
 
-export { AggregateErrorPonyfill as A, deepMerge as B, ensurePackageInstalled as C, stdout as D, mergeSlashes as E, getAllMockableProperties as F, RealDate as R, resetModules as a, getCallLastIndex as b, getNames as c, assertTypes as d, getFullName as e, isRunningInTest as f, getWorkerState as g, isRunningInBenchmark as h, isObject as i, notNullish as j, deepClone as k, getType as l, mockDate as m, noop as n, relativePath as o, partitionSuiteChildren as p, shuffle as q, resetDate as r, slash as s, toArray as t, hasTests as u, hasFailed as v, createDefer as w, getTests as x, hasFailedSnapshot as y, getSuites as z };
+export { AggregateErrorPonyfill as A, getTypecheckTests as B, getSuites as C, isTypecheckTest as D, deepMerge as E, removeUndefinedValues as F, stdout as G, mergeSlashes as H, getAllMockableProperties as I, RealDate as R, TYPECHECK_SUITE as T, resetModules as a, getCallLastIndex as b, getNames as c, assertTypes as d, getFullName as e, isRunningInTest as f, getWorkerState as g, isRunningInBenchmark as h, isObject as i, notNullish as j, relativePath as k, shuffle as l, mockDate as m, noop as n, hasTests as o, partitionSuiteChildren as p, hasFailed as q, resetDate as r, slash as s, toArray as t, createDefer as u, deepClone as v, getType as w, ensurePackageInstalled as x, getTests as y, hasFailedSnapshot as z };

package/dist/{chunk-utils-env.b1281522.js → chunk-utils-env.7fe285cc.js}

@@ -277,6 +277,8 @@ const globalApis = [
   "chai",
   "expect",
   "assert",
+  "expectTypeOf",
+  "assertType",
   "vitest",
   "vi",
   "beforeAll",

package/dist/chunk-utils-source-map.1a66263d.js

@@ -0,0 +1,90 @@
+import { s as slash, j as notNullish } from './chunk-typecheck-constants.410fa7b2.js';
+
+const lineSplitRE = /\r?\n/;
+const stackIgnorePatterns = [
+  "node:internal",
+  "/vitest/dist/",
+  "/vitest/src/",
+  "/node_modules/chai/",
+  "/node_modules/tinypool/",
+  "/node_modules/tinyspy/"
+];
+function extractLocation(urlLike) {
+  if (!urlLike.includes(":"))
+    return [urlLike];
+  const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+  const parts = regExp.exec(urlLike.replace(/[()]/g, ""));
+  if (!parts)
+    return [urlLike];
+  return [parts[1], parts[2] || void 0, parts[3] || void 0];
+}
+function parseStacktrace(e, full = false) {
+  if (!e)
+    return [];
+  if (e.stacks)
+    return e.stacks;
+  const stackStr = e.stack || e.stackStr || "";
+  const stackFrames = stackStr.split("\n").map((raw) => {
+    let line = raw.trim();
+    if (line.includes("(eval "))
+      line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+    let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+    const location = sanitizedLine.match(/ (\(.+\)$)/);
+    sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+    const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
+    let method = location && sanitizedLine || "";
+    let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
+    if (!file || !lineNumber || !columnNumber)
+      return null;
+    if (method.startsWith("async "))
+      method = method.slice(6);
+    if (file.startsWith("file://"))
+      file = file.slice(7);
+    if (!full && stackIgnorePatterns.some((p) => file && file.includes(p)))
+      return null;
+    return {
+      method,
+      file: slash(file),
+      line: parseInt(lineNumber),
+      column: parseInt(columnNumber)
+    };
+  }).filter(notNullish);
+  e.stacks = stackFrames;
+  return stackFrames;
+}
+function posToNumber(source, pos) {
+  if (typeof pos === "number")
+    return pos;
+  const lines = source.split(lineSplitRE);
+  const { line, column } = pos;
+  let start = 0;
+  if (line > lines.length)
+    return source.length;
+  for (let i = 0; i < line - 1; i++)
+    start += lines[i].length + 1;
+  return start + column;
+}
+function numberToPos(source, offset) {
+  if (typeof offset !== "number")
+    return offset;
+  if (offset > source.length) {
+    throw new Error(
+      `offset is longer than source length! offset ${offset} > length ${source.length}`
+    );
+  }
+  const lines = source.split(lineSplitRE);
+  let counted = 0;
+  let line = 0;
+  let column = 0;
+  for (; line < lines.length; line++) {
+    const lineLength = lines[line].length + 1;
+    if (counted + lineLength >= offset) {
+      column = offset - counted + 1;
+      break;
+    }
+    counted += lineLength;
+  }
+  return { line: line + 1, column };
+}
+
+export { posToNumber as a, lineSplitRE as l, numberToPos as n, parseStacktrace as p };