vitest 0.29.8 → 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-runtime-mocker.3283818a.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, a as getCurrentEnvironment } from './chunk-utils-global.fd174983.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 { f as getAllMockableProperties } from './chunk-utils-base.b5ddfcc9.js';
+import { e as getAllMockableProperties } from './vendor-index.4f82d248.js';
 import { spyOn } from '@vitest/spy';
-import { r as rpc } from './chunk-runtime-rpc.d6aa57f8.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/{chunk-utils-base.b5ddfcc9.js → vendor-index.4f82d248.js}

@@ -1,3 +1,5 @@
+import '@vitest/utils';
+
 function isFinalObj(obj) {
   return obj === Object.prototype || obj === Function.prototype || obj === RegExp.prototype;
 }
@@ -36,14 +38,11 @@ function getAllMockableProperties(obj, isModule) {
   }
   return Array.from(allProps.values());
 }
-function notNullish(v) {
-  return v != null;
-}
 function slash(str) {
   return str.replace(/\\/g, "/");
 }
-const noop = () => {
-};
+function noop() {
+}
 function toArray(array) {
   if (array === null || array === void 0)
     array = [];
@@ -51,10 +50,11 @@ function toArray(array) {
     return array;
   return [array];
 }
-const toString = (v) => Object.prototype.toString.call(v);
-const isPlainObject = (val) => toString(val) === "[object Object]" && (!val.constructor || val.constructor.name === "Object");
-function isObject(item) {
-  return item != null && typeof item === "object" && !Array.isArray(item);
+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)
@@ -88,4 +88,74 @@ function getEnvironmentTransformMode(config, environment) {
   return environment === "happy-dom" || environment === "jsdom" ? "web" : "ssr";
 }
 
-export { isPrimitive as a, getEnvironmentTransformMode as b, noop as c, deepMerge as d, stdout as e, getAllMockableProperties as f, groupBy as g, isObject as i, notNullish as n, slash as s, toArray as t };
+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.23c19408.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.e488ace3.js';
-import { r as runOnce, i as isFirstRun } from './chunk-integrations-run-once.ea614f17.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 };