vitest 0.29.7 → 0.30.0

package/dist/vendor-constants.538d9b49.js

@@ -0,0 +1,54 @@
+const defaultPort = 51204;
+const defaultBrowserPort = 63315;
+const EXIT_CODE_RESTART = 43;
+const API_PATH = "/__vitest_api__";
+const CONFIG_NAMES = [
+  "vitest.config",
+  "vite.config"
+];
+const WORKSPACES_NAMES = [
+  "vitest.workspace",
+  "vitest.projects"
+];
+const CONFIG_EXTENSIONS = [
+  ".ts",
+  ".mts",
+  ".cts",
+  ".js",
+  ".mjs",
+  ".cjs"
+];
+const configFiles = CONFIG_NAMES.flatMap(
+  (name) => CONFIG_EXTENSIONS.map((ext) => name + ext)
+);
+const WORKSPACES_EXTENSIONS = [
+  ...CONFIG_EXTENSIONS,
+  ".json"
+];
+const workspacesFiles = WORKSPACES_NAMES.flatMap(
+  (name) => WORKSPACES_EXTENSIONS.map((ext) => name + ext)
+);
+const globalApis = [
+  // suite
+  "suite",
+  "test",
+  "describe",
+  "it",
+  // chai
+  "chai",
+  "expect",
+  "assert",
+  // typecheck
+  "expectTypeOf",
+  "assertType",
+  // utils
+  "vitest",
+  "vi",
+  // hooks
+  "beforeAll",
+  "afterAll",
+  "beforeEach",
+  "afterEach"
+];
+
+export { API_PATH as A, CONFIG_NAMES as C, EXIT_CODE_RESTART as E, defaultBrowserPort as a, configFiles as c, defaultPort as d, globalApis as g, workspacesFiles as w };

package/dist/{chunk-integrations-coverage.e0a6acd2.js → vendor-coverage.a585b712.js}

@@ -1,5 +1,3 @@
-import { importModule } from 'local-pkg';
-
 const CoverageProviderMap = {
   c8: "@vitest/coverage-c8",
   istanbul: "@vitest/coverage-istanbul"
@@ -8,8 +6,10 @@ async function resolveCoverageProviderModule(options, loader) {
   if (!(options == null ? void 0 : options.enabled) || !options.provider)
     return null;
   const provider = options.provider;
-  if (provider === "c8" || provider === "istanbul")
-    return await importModule(CoverageProviderMap[provider]);
+  if (provider === "c8" || provider === "istanbul") {
+    const { default: coverageModule } = await loader.executeId(CoverageProviderMap[provider]);
+    return coverageModule;
+  }
   let customProviderModule;
   try {
     customProviderModule = await loader.executeId(options.customProviderModule);
@@ -48,4 +48,4 @@ async function stopCoverageInsideWorker(options, loader) {
   return null;
 }
 
-export { CoverageProviderMap as C, stopCoverageInsideWorker as a, getCoverageProvider as g, startCoverageInsideWorker as s, takeCoverageInsideWorker as t };
+export { CoverageProviderMap as C, startCoverageInsideWorker as a, getCoverageProvider as g, stopCoverageInsideWorker as s, takeCoverageInsideWorker as t };

package/dist/{chunk-runtime-mocker.344fec90.js → vendor-execute.8eaab47b.js}

@@ -1,16 +1,15 @@
 import { pathToFileURL } from 'node:url';
 import { ModuleCacheMap, ViteNodeRunner } from 'vite-node/client';
-import { isInternalRequest, isPrimitive } from 'vite-node/utils';
+import { isNodeBuiltin, isInternalRequest, isPrimitive } from 'vite-node/utils';
 import { isAbsolute, dirname, join, basename, extname, resolve, normalize, relative } from 'pathe';
-import { i as isNodeBuiltin } from './vendor-index.bdee400f.js';
 import { processError } from '@vitest/runner/utils';
-import { g as getWorkerState, b as getCurrentEnvironment } from './chunk-utils-env.04ffbef7.js';
-import { d as distDir } from './chunk-paths.e36446b4.js';
+import { g as getWorkerState, a as getCurrentEnvironment } from './vendor-global.6795f91f.js';
+import { d as distDir } from './vendor-paths.84fc7a99.js';
 import { existsSync, readdirSync } from 'node:fs';
 import { getColors, getType } from '@vitest/utils';
-import { e as getAllMockableProperties } from './chunk-utils-base.81f83dbd.js';
+import { e as getAllMockableProperties } from './vendor-index.4f82d248.js';
 import { spyOn } from '@vitest/spy';
-import { r as rpc } from './chunk-runtime-rpc.1b5714dc.js';
+import { r as rpc } from './vendor-rpc.4d3d7a54.js';
 
 const filterPublicKeys = ["__esModule", Symbol.asyncIterator, Symbol.hasInstance, Symbol.isConcatSpreadable, Symbol.iterator, Symbol.match, Symbol.matchAll, Symbol.replace, Symbol.search, Symbol.split, Symbol.species, Symbol.toPrimitive, Symbol.toStringTag, Symbol.unscopables];
 class RefTracker {
@@ -42,9 +41,6 @@ const _VitestMocker = class {
   get root() {
     return this.executor.options.root;
   }
-  get base() {
-    return this.executor.options.base;
-  }
   get mockMap() {
     return this.executor.options.mockMap;
   }
@@ -318,11 +314,12 @@ async function startViteNode(ctx) {
     var _a;
     const worker = getWorkerState();
     const error = processError(err);
-    if (worker.filepath && !isPrimitive(error)) {
+    if (!isPrimitive(error)) {
       error.VITEST_TEST_NAME = (_a = worker.current) == null ? void 0 : _a.name;
-      error.VITEST_TEST_PATH = relative(config.root, worker.filepath);
+      if (worker.filepath)
+        error.VITEST_TEST_PATH = relative(config.root, worker.filepath);
+      error.VITEST_AFTER_ENV_TEARDOWN = worker.environmentTeardownRun;
     }
-    error.VITEST_AFTER_ENV_TEARDOWN = worker.environmentTeardownRun;
     rpc().onUnhandledError(error, type);
   }
   process.on("uncaughtException", (e) => catchError(e, "Uncaught Exception"));

package/dist/vendor-global.6795f91f.js

@@ -0,0 +1,8 @@
+function getWorkerState() {
+  return globalThis.__vitest_worker__;
+}
+function getCurrentEnvironment() {
+  return globalThis.__vitest_environment__;
+}
+
+export { getCurrentEnvironment as a, getWorkerState as g };

package/dist/vendor-index.4f82d248.js

@@ -0,0 +1,161 @@
+import '@vitest/utils';
+
+function isFinalObj(obj) {
+  return obj === Object.prototype || obj === Function.prototype || obj === RegExp.prototype;
+}
+function collectOwnProperties(obj, collector) {
+  const collect = typeof collector === "function" ? collector : (key) => collector.add(key);
+  Object.getOwnPropertyNames(obj).forEach(collect);
+  Object.getOwnPropertySymbols(obj).forEach(collect);
+}
+function groupBy(collection, iteratee) {
+  return collection.reduce((acc, item) => {
+    const key = iteratee(item);
+    acc[key] || (acc[key] = []);
+    acc[key].push(item);
+    return acc;
+  }, {});
+}
+function isPrimitive(value) {
+  return value === null || typeof value !== "function" && typeof value !== "object";
+}
+function getAllMockableProperties(obj, isModule) {
+  const allProps = /* @__PURE__ */ new Map();
+  let curr = obj;
+  do {
+    if (isFinalObj(curr))
+      break;
+    collectOwnProperties(curr, (key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(curr, key);
+      if (descriptor)
+        allProps.set(key, { key, descriptor });
+    });
+  } while (curr = Object.getPrototypeOf(curr));
+  if (isModule && !allProps.has("default") && "default" in obj) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, "default");
+    if (descriptor)
+      allProps.set("default", { key: "default", descriptor });
+  }
+  return Array.from(allProps.values());
+}
+function slash(str) {
+  return str.replace(/\\/g, "/");
+}
+function noop() {
+}
+function toArray(array) {
+  if (array === null || array === void 0)
+    array = [];
+  if (Array.isArray(array))
+    return array;
+  return [array];
+}
+function toString(v) {
+  return Object.prototype.toString.call(v);
+}
+function isPlainObject(val) {
+  return toString(val) === "[object Object]" && (!val.constructor || val.constructor.name === "Object");
+}
+function deepMerge(target, ...sources) {
+  if (!sources.length)
+    return target;
+  const source = sources.shift();
+  if (source === void 0)
+    return target;
+  if (isMergeableObject(target) && isMergeableObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isMergeableObject(source[key])) {
+        if (!target[key])
+          target[key] = {};
+        deepMerge(target[key], source[key]);
+      } else {
+        target[key] = source[key];
+      }
+    });
+  }
+  return deepMerge(target, ...sources);
+}
+function isMergeableObject(item) {
+  return isPlainObject(item) && !Array.isArray(item);
+}
+function stdout() {
+  return console._stdout || process.stdout;
+}
+function getEnvironmentTransformMode(config, environment) {
+  var _a, _b;
+  if (!((_b = (_a = config.deps) == null ? void 0 : _a.experimentalOptimizer) == null ? void 0 : _b.enabled))
+    return void 0;
+  return environment === "happy-dom" || environment === "jsdom" ? "web" : "ssr";
+}
+
+const DEFAULT_TIMEOUT = 6e4;
+function createBirpc(functions, options) {
+  const {
+    post,
+    on,
+    eventNames = [],
+    serialize = (i) => i,
+    deserialize = (i) => i,
+    timeout = DEFAULT_TIMEOUT
+  } = options;
+  const rpcPromiseMap = /* @__PURE__ */ new Map();
+  const rpc = new Proxy({}, {
+    get(_, method) {
+      const sendEvent = (...args) => {
+        post(serialize({ m: method, a: args, t: "q" }));
+      };
+      if (eventNames.includes(method)) {
+        sendEvent.asEvent = sendEvent;
+        return sendEvent;
+      }
+      const sendCall = (...args) => {
+        return new Promise((resolve, reject) => {
+          const id = nanoid();
+          rpcPromiseMap.set(id, { resolve, reject });
+          post(serialize({ m: method, a: args, i: id, t: "q" }));
+          if (timeout >= 0) {
+            setTimeout(() => {
+              reject(new Error(`[birpc] timeout on calling "${method}"`));
+              rpcPromiseMap.delete(id);
+            }, timeout);
+          }
+        });
+      };
+      sendCall.asEvent = sendEvent;
+      return sendCall;
+    }
+  });
+  on(async (data, ...extra) => {
+    const msg = deserialize(data);
+    if (msg.t === "q") {
+      const { m: method, a: args } = msg;
+      let result, error;
+      try {
+        result = await functions[method].apply(rpc, args);
+      } catch (e) {
+        error = e;
+      }
+      if (msg.i)
+        post(serialize({ t: "s", i: msg.i, r: result, e: error }), ...extra);
+    } else {
+      const { i: ack, r: result, e: error } = msg;
+      const promise = rpcPromiseMap.get(ack);
+      if (error)
+        promise?.reject(error);
+      else
+        promise?.resolve(result);
+      rpcPromiseMap.delete(ack);
+    }
+  });
+  return rpc;
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+  let id = "";
+  let i = size;
+  while (i--)
+    id += urlAlphabet[Math.random() * 64 | 0];
+  return id;
+}
+
+export { getEnvironmentTransformMode as a, stdout as b, createBirpc as c, deepMerge as d, getAllMockableProperties as e, groupBy as g, isPrimitive as i, noop as n, slash as s, toArray as t };

package/dist/{chunk-env-node.affdd278.js → vendor-index.75f2b63d.js}

@@ -176,6 +176,7 @@ const LIVING_KEYS = [
   "AbortController",
   "AbortSignal",
   "ArrayBuffer",
+  // not specified in docs, but is available
   "Image",
   "Audio",
   "Option"
@@ -187,8 +188,11 @@ const OTHER_KEYS = [
   "blur",
   "btoa",
   "cancelAnimationFrame",
+  /* 'clearInterval', */
+  /* 'clearTimeout', */
   "close",
   "confirm",
+  /* 'console', */
   "createPopup",
   "dispatchEvent",
   "document",
@@ -231,7 +235,10 @@ const OTHER_KEYS = [
   "scrollX",
   "scrollY",
   "self",
+  /* 'setInterval', */
+  /* 'setTimeout', */
   "stop",
+  /* 'toString', */
   "top",
   "Window",
   "window"
@@ -422,12 +429,12 @@ const envPackageNames = {
   "happy-dom": "happy-dom",
   "edge-runtime": "@edge-runtime/vm"
 };
-const getEnvPackageName = (env) => {
+function getEnvPackageName(env) {
   if (env === "node")
     return null;
   if (env in envPackageNames)
     return envPackageNames[env];
   return `vitest-environment-${env}`;
-};
+}
 
 export { environments as e, getEnvPackageName as g, populateGlobal as p };

package/dist/{chunk-integrations-utils.d7c85bd9.js → vendor-index.81b9e499.js}

@@ -1,6 +1,6 @@
-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.39ffe9c5.js';
-import { r as runOnce, i as isFirstRun } from './chunk-integrations-run-once.a2b4758b.js';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
+import { e as bench, c as createExpect, d as globalExpect, s as setupChaiConfig, v as vi, f as vitest } from './vendor-vi.a3ff54b1.js';
+import { i as isFirstRun, a as runOnce } from './vendor-run-once.69ce7172.js';
 import * as chai from 'chai';
 import { assert, should } from 'chai';
 
@@ -84,35 +84,36 @@ var dist = {};
 	exports.expectTypeOf = expectTypeOf;
 } (dist));
 
-const noop = () => {
-};
+function 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,
+  assertType: assertType,
+  beforeAll: beforeAll,
+  beforeEach: beforeEach,
+  bench: bench,
   chai: chai,
+  createExpect: createExpect,
+  describe: describe,
   expect: globalExpect,
-  vitest: vitest,
-  vi: vi,
+  expectTypeOf: dist.expectTypeOf,
   getRunningMode: getRunningMode,
+  isFirstRun: isFirstRun,
   isWatchMode: isWatchMode,
-  expectTypeOf: dist.expectTypeOf,
-  assertType: assertType
+  it: it,
+  onTestFailed: onTestFailed,
+  runOnce: runOnce,
+  setupChaiConfig: setupChaiConfig,
+  should: should,
+  suite: suite,
+  test: test,
+  vi: vi,
+  vitest: vitest
 });
 
 export { isWatchMode as a, assertType as b, dist as d, getRunningMode as g, index as i };