vitest 0.27.2 → 0.28.0

package/dist/chunk-integrations-globals.0d5f50f0.js

@@ -0,0 +1,29 @@
+import { g as globalApis } from './chunk-constants.797d3ebf.js';
+import { i as index } from './chunk-integrations-utils.f1f6f1ed.js';
+import 'node:url';
+import 'pathe';
+import './chunk-utils-env.860d90c2.js';
+import 'std-env';
+import '@vitest/runner';
+import './chunk-utils-import.9911c99d.js';
+import '@vitest/runner/utils';
+import '@vitest/utils';
+import './chunk-utils-global.442d1d33.js';
+import 'chai';
+import './vendor-_commonjsHelpers.addc3445.js';
+import '@vitest/expect';
+import './chunk-runtime-rpc.9c0386cc.js';
+import './chunk-snapshot-env.6457638e.js';
+import './chunk-utils-base.977ae74f.js';
+import './chunk-utils-tasks.1b603032.js';
+import 'util';
+import '@vitest/spy';
+import './chunk-integrations-run-once.38756e30.js';
+
+function registerApiGlobally() {
+  globalApis.forEach((api) => {
+    globalThis[api] = index[api];
+  });
+}
+
+export { registerApiGlobally };

package/dist/chunk-integrations-run-once.38756e30.js

@@ -0,0 +1,27 @@
+import { g as getWorkerState } from './chunk-utils-global.442d1d33.js';
+
+const filesCount = /* @__PURE__ */ new Map();
+const cache = /* @__PURE__ */ new Map();
+function runOnce(fn, key) {
+  const filepath = getWorkerState().filepath || "__unknown_files__";
+  if (!key) {
+    filesCount.set(filepath, (filesCount.get(filepath) || 0) + 1);
+    key = String(filesCount.get(filepath));
+  }
+  const id = `${filepath}:${key}`;
+  if (!cache.has(id))
+    cache.set(id, fn());
+  return cache.get(id);
+}
+function isFirstRun() {
+  let firstRun = false;
+  runOnce(() => {
+    firstRun = true;
+  }, "__vitest_first_run__");
+  return firstRun;
+}
+function resetRunOnceCounter() {
+  filesCount.clear();
+}
+
+export { resetRunOnceCounter as a, isFirstRun as i, runOnce as r };

package/dist/chunk-integrations-utils.f1f6f1ed.js

@@ -0,0 +1,118 @@
+import { suite, test, describe, it, beforeAll, beforeEach, afterAll, afterEach, onTestFailed } from '@vitest/runner';
+import { b as bench, c as createExpect, g as globalExpect, v as vitest, a as vi } from './chunk-utils-import.9911c99d.js';
+import { r as runOnce, i as isFirstRun } from './chunk-integrations-run-once.38756e30.js';
+import * as chai from 'chai';
+import { assert, should } from 'chai';
+
+function getRunningMode() {
+  return process.env.VITEST_MODE === "WATCH" ? "watch" : "run";
+}
+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,
+  test: test,
+  describe: describe,
+  it: it,
+  beforeAll: beforeAll,
+  beforeEach: beforeEach,
+  afterAll: afterAll,
+  afterEach: afterEach,
+  onTestFailed: onTestFailed,
+  bench: bench,
+  runOnce: runOnce,
+  isFirstRun: isFirstRun,
+  assert: assert,
+  should: should,
+  createExpect: createExpect,
+  chai: chai,
+  expect: globalExpect,
+  vitest: vitest,
+  vi: vi,
+  getRunningMode: getRunningMode,
+  isWatchMode: isWatchMode,
+  expectTypeOf: dist.expectTypeOf,
+  assertType: assertType
+});
+
+export { isWatchMode as a, assertType as b, dist as d, getRunningMode as g, index as i };

package/dist/{chunk-node-git.125c9008.js → chunk-node-git.d9ad64ab.js}

@@ -1,22 +1,21 @@
-import { b as resolve } from './chunk-utils-env.f4a39d2c.js';
-import { e as execa } from './vendor-index.451e37bc.js';
-import 'node:url';
-import 'path';
+import { resolve } from 'pathe';
+import { e as execa } from './vendor-index.618ca5a1.js';
 import 'node:buffer';
 import 'node:path';
 import 'node:child_process';
 import 'node:process';
-import './vendor-index.e6c27006.js';
 import 'child_process';
+import 'path';
 import './vendor-_commonjsHelpers.addc3445.js';
 import 'fs';
+import 'node:url';
+import 'os';
+import 'node:os';
 import 'assert';
 import 'events';
 import 'buffer';
 import 'stream';
 import 'util';
-import 'os';
-import 'node:os';
 
 class VitestGit {
   constructor(cwd) {