vitest 0.25.8 → 0.26.1

package/dist/vendor-index.2e96c50b.js

@@ -0,0 +1,215 @@
+import 'acorn';
+import { builtinModules } from 'node:module';
+import 'node:fs';
+import { pathToFileURL } from 'node:url';
+import 'url';
+import 'fs';
+import 'path';
+import 'module';
+import assert from 'assert';
+import { format, inspect } from 'util';
+import 'node:path';
+
+const BUILTIN_MODULES = new Set(builtinModules);
+
+const isWindows = process.platform === "win32";
+const own$1 = {}.hasOwnProperty;
+const messages = /* @__PURE__ */ new Map();
+const nodeInternalPrefix = "__node_internal_";
+let userStackTraceLimit;
+createError(
+  "ERR_INVALID_MODULE_SPECIFIER",
+  (request, reason, base = void 0) => {
+    return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
+  },
+  TypeError
+);
+createError(
+  "ERR_INVALID_PACKAGE_CONFIG",
+  (path, base, message) => {
+    return `Invalid package config ${path}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  },
+  Error
+);
+createError(
+  "ERR_INVALID_PACKAGE_TARGET",
+  (pkgPath, key, target, isImport = false, base = void 0) => {
+    const relError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
+    if (key === ".") {
+      assert(isImport === false);
+      return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`;
+    }
+    return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(
+      target
+    )} defined for '${key}' in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`;
+  },
+  Error
+);
+createError(
+  "ERR_MODULE_NOT_FOUND",
+  (path, base, type = "package") => {
+    return `Cannot find ${type} '${path}' imported from ${base}`;
+  },
+  Error
+);
+createError(
+  "ERR_PACKAGE_IMPORT_NOT_DEFINED",
+  (specifier, packagePath, base) => {
+    return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ""} imported from ${base}`;
+  },
+  TypeError
+);
+createError(
+  "ERR_PACKAGE_PATH_NOT_EXPORTED",
+  (pkgPath, subpath, base = void 0) => {
+    if (subpath === ".") {
+      return `No "exports" main defined in ${pkgPath}package.json${base ? ` imported from ${base}` : ""}`;
+    }
+    return `Package subpath '${subpath}' is not defined by "exports" in ${pkgPath}package.json${base ? ` imported from ${base}` : ""}`;
+  },
+  Error
+);
+createError(
+  "ERR_UNSUPPORTED_DIR_IMPORT",
+  "Directory import '%s' is not supported resolving ES modules imported from %s",
+  Error
+);
+createError(
+  "ERR_UNKNOWN_FILE_EXTENSION",
+  'Unknown file extension "%s" for %s',
+  TypeError
+);
+createError(
+  "ERR_INVALID_ARG_VALUE",
+  (name, value, reason = "is invalid") => {
+    let inspected = inspect(value);
+    if (inspected.length > 128) {
+      inspected = `${inspected.slice(0, 128)}...`;
+    }
+    const type = name.includes(".") ? "property" : "argument";
+    return `The ${type} '${name}' ${reason}. Received ${inspected}`;
+  },
+  TypeError
+);
+createError(
+  "ERR_UNSUPPORTED_ESM_URL_SCHEME",
+  (url) => {
+    let message = "Only file and data URLs are supported by the default ESM loader";
+    if (isWindows && url.protocol.length === 2) {
+      message += ". On Windows, absolute paths must be valid file:// URLs";
+    }
+    message += `. Received protocol '${url.protocol}'`;
+    return message;
+  },
+  Error
+);
+function createError(sym, value, def) {
+  messages.set(sym, value);
+  return makeNodeErrorWithCode(def, sym);
+}
+function makeNodeErrorWithCode(Base, key) {
+  return NodeError;
+  function NodeError(...args) {
+    const limit = Error.stackTraceLimit;
+    if (isErrorStackTraceLimitWritable()) {
+      Error.stackTraceLimit = 0;
+    }
+    const error = new Base();
+    if (isErrorStackTraceLimitWritable()) {
+      Error.stackTraceLimit = limit;
+    }
+    const message = getMessage(key, args, error);
+    Object.defineProperty(error, "message", {
+      value: message,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+    Object.defineProperty(error, "toString", {
+      value() {
+        return `${this.name} [${key}]: ${this.message}`;
+      },
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+    addCodeToName(error, Base.name, key);
+    error.code = key;
+    return error;
+  }
+}
+const addCodeToName = hideStackFrames(
+  function(error, name, code) {
+    error = captureLargerStackTrace(error);
+    error.name = `${name} [${code}]`;
+    error.stack;
+    if (name === "SystemError") {
+      Object.defineProperty(error, "name", {
+        value: name,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
+    } else {
+      delete error.name;
+    }
+  }
+);
+function isErrorStackTraceLimitWritable() {
+  const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+  if (desc === void 0) {
+    return Object.isExtensible(Error);
+  }
+  return own$1.call(desc, "writable") ? desc.writable : desc.set !== void 0;
+}
+function hideStackFrames(fn) {
+  const hidden = nodeInternalPrefix + fn.name;
+  Object.defineProperty(fn, "name", { value: hidden });
+  return fn;
+}
+const captureLargerStackTrace = hideStackFrames(
+  function(error) {
+    const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+    if (stackTraceLimitIsWritable) {
+      userStackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+    }
+    Error.captureStackTrace(error);
+    if (stackTraceLimitIsWritable) {
+      Error.stackTraceLimit = userStackTraceLimit;
+    }
+    return error;
+  }
+);
+function getMessage(key, args, self) {
+  const message = messages.get(key);
+  if (typeof message === "function") {
+    assert(
+      message.length <= args.length,
+      `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${message.length}).`
+    );
+    return Reflect.apply(message, self, args);
+  }
+  const expectedLength = (message.match(/%[dfijoOs]/g) || []).length;
+  assert(
+    expectedLength === args.length,
+    `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`
+  );
+  if (args.length === 0) {
+    return message;
+  }
+  args.unshift(message);
+  return Reflect.apply(format, null, args);
+}
+Object.freeze(["node", "import"]);
+function isNodeBuiltin(id = "") {
+  id = id.replace(/^node:/, "").split("/")[0];
+  return BUILTIN_MODULES.has(id);
+}
+pathToFileURL(process.cwd());
+const CJS_RE = /([\s;]|^)(module.exports\b|exports\.\w|require\s*\(|global\.\w)/m;
+function hasCJSSyntax(code) {
+  return CJS_RE.test(code);
+}
+
+export { hasCJSSyntax as h, isNodeBuiltin as i };

package/dist/vendor-index.783e7f3e.js

@@ -0,0 +1,71 @@
+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 { createBirpc as c };

package/dist/{vendor-index.e1d4cf84.js → vendor-index.7a2cebfe.js}

@@ -1,11 +1,11 @@
-import childProcess from 'child_process';
-import path$3 from 'path';
+import require$$0$1 from 'child_process';
+import g from 'path';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.addc3445.js';
-import fs$1 from 'fs';
+import require$$0 from 'fs';
 import assert$1 from 'assert';
 import require$$2 from 'events';
-import require$$0$1 from 'buffer';
-import require$$0 from 'stream';
+import require$$0$3 from 'buffer';
+import require$$0$2 from 'stream';
 import util from 'util';
 
 var crossSpawn = {exports: {}};
@@ -19,7 +19,7 @@ function requireWindows () {
 	windows = isexe;
 	isexe.sync = sync;
 
-	var fs = fs$1;
+	var fs = require$$0;
 
 	function checkPathExt (path, options) {
 	  var pathext = options.pathExt !== undefined ?
@@ -70,7 +70,7 @@ function requireMode () {
 	mode = isexe;
 	isexe.sync = sync;
 
-	var fs = fs$1;
+	var fs = require$$0;
 
 	function isexe (path, options, cb) {
 	  fs.stat(path, function (er, stat) {
@@ -172,7 +172,7 @@ const isWindows = process.platform === 'win32' ||
     process.env.OSTYPE === 'cygwin' ||
     process.env.OSTYPE === 'msys';
 
-const path$2 = path$3;
+const path$2 = g;
 const COLON = isWindows ? ';' : ':';
 const isexe = isexe_1;
 
@@ -311,7 +311,7 @@ pathKey$1.exports = pathKey;
 // TODO: Remove this for the next major release
 pathKey$1.exports.default = pathKey;
 
-const path$1 = path$3;
+const path$1 = g;
 const which = which_1;
 const getPathKey = pathKey$1.exports;
 
@@ -429,7 +429,7 @@ var shebangCommand$1 = (string = '') => {
 	return argument ? `${binary} ${argument}` : binary;
 };
 
-const fs = fs$1;
+const fs = require$$0;
 const shebangCommand = shebangCommand$1;
 
 function readShebang$1(command) {
@@ -451,7 +451,7 @@ function readShebang$1(command) {
 
 var readShebang_1 = readShebang$1;
 
-const path = path$3;
+const path = g;
 const resolveCommand = resolveCommand_1;
 const escape = _escape;
 const readShebang = readShebang_1;
@@ -599,7 +599,7 @@ var enoent$1 = {
     notFoundError,
 };
 
-const cp = childProcess;
+const cp = require$$0$1;
 const parse = parse_1;
 const enoent = enoent$1;
 
@@ -909,7 +909,7 @@ if (!processOk(process$1)) {
 
 var getStream$1 = {exports: {}};
 
-const {PassThrough: PassThroughStream} = require$$0;
+const {PassThrough: PassThroughStream} = require$$0$2;
 
 var bufferStream$1 = options => {
 	options = {...options};
@@ -961,8 +961,8 @@ var bufferStream$1 = options => {
 	return stream;
 };
 
-const {constants: BufferConstants} = require$$0$1;
-const stream = require$$0;
+const {constants: BufferConstants} = require$$0$3;
+const stream = require$$0$2;
 const {promisify} = util;
 const bufferStream = bufferStream$1;
 
@@ -1022,7 +1022,7 @@ getStream$1.exports.buffer = (stream, options) => getStream(stream, {...options,
 getStream$1.exports.array = (stream, options) => getStream(stream, {...options, array: true});
 getStream$1.exports.MaxBufferError = MaxBufferError;
 
-const { PassThrough } = require$$0;
+const { PassThrough } = require$$0$2;
 
 var mergeStream = function (/*streams...*/) {
   var sources = [];

package/dist/{vendor-index.737c3cff.js → vendor-index.b2fdde54.js}

@@ -1,10 +1,11 @@
-import { Buffer } from 'buffer';
-import path from 'path';
-import childProcess from 'child_process';
-import process$1 from 'process';
-import { s as signalExit, m as mergeStream, g as getStream, c as crossSpawn } from './vendor-index.e1d4cf84.js';
-import url from 'url';
-import require$$0, { constants } from 'os';
+import { Buffer } from 'node:buffer';
+import path from 'node:path';
+import childProcess from 'node:child_process';
+import process$1 from 'node:process';
+import { s as signalExit, m as mergeStream, g as getStream, c as crossSpawn } from './vendor-index.7a2cebfe.js';
+import url from 'node:url';
+import { constants } from 'os';
+import os from 'node:os';
 
 function stripFinalNewline(input) {
 	const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();
@@ -704,7 +705,7 @@ const setKillTimeout = (kill, signal, options, killResult) => {
 
 const shouldForceKill = (signal, {forceKillAfterTimeout}, killResult) => isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
 
-const isSigterm = signal => signal === require$$0.constants.signals.SIGTERM
+const isSigterm = signal => signal === os.constants.signals.SIGTERM
 		|| (typeof signal === 'string' && signal.toUpperCase() === 'SIGTERM');
 
 const getForceKillAfterTimeout = ({forceKillAfterTimeout = true}) => {

package/dist/worker.js

@@ -1,26 +1,28 @@
-import { b as resolve, e as distDir } from './chunk-utils-env.03f840f2.js';
-import { c as createBirpc, M as ModuleCacheMap } from './chunk-vite-node-source-map.b4ea5792.js';
+import { b as resolve, e as distDir } from './chunk-utils-env.3fdc1793.js';
+import { c as createBirpc } from './vendor-index.783e7f3e.js';
 import { workerId } from 'tinypool';
-import { g as getWorkerState } from './chunk-typecheck-constants.ed987901.js';
-import { e as executeInViteNode } from './chunk-runtime-mocker.99b910d0.js';
-import { r as rpc } from './chunk-runtime-rpc.42aebbb9.js';
-import { p as processError } from './chunk-runtime-error.616e92ca.js';
+import { ModuleCacheMap } from 'vite-node/client';
+import { g as getWorkerState } from './chunk-typecheck-constants.06e1fe5b.js';
+import { e as executeInViteNode } from './chunk-runtime-mocker.3fa602ba.js';
+import { r as rpc } from './chunk-runtime-rpc.54d72169.js';
+import { p as processError } from './chunk-runtime-error.f5c8aaf2.js';
 import 'tty';
-import 'url';
+import 'node:url';
 import 'path';
-import 'module';
-import 'vm';
-import './chunk-vite-node-utils.0e4a6a88.js';
-import 'fs';
+import 'node:path';
+import 'local-pkg';
+import 'vite-node/utils';
+import 'vite';
+import './vendor-index.2e96c50b.js';
 import 'acorn';
+import 'node:module';
+import 'node:fs';
+import 'url';
+import 'fs';
+import 'module';
 import 'assert';
 import 'util';
-import 'debug';
-import './vendor-source-map-support.1ce17397.js';
-import 'source-map';
-import 'local-pkg';
-import 'vite';
-import './chunk-utils-timers.793fd179.js';
+import './chunk-utils-timers.715da787.js';
 import 'chai';
 
 let _viteNode;
@@ -53,7 +55,7 @@ async function startViteNode(ctx) {
     },
     moduleCache,
     mockMap,
-    interopDefault: config.deps.interopDefault ?? true,
+    interopDefault: config.deps.interopDefault,
     root: config.root,
     base: config.base
   }))[0];
@@ -66,6 +68,7 @@ function init(ctx) {
   const { config, port, workerId: workerId$1 } = ctx;
   process.env.VITEST_WORKER_ID = String(workerId$1);
   process.env.VITEST_POOL_ID = String(workerId);
+  globalThis.__vitest_environment__ = config.environment;
   globalThis.__vitest_worker__ = {
     ctx,
     moduleCache,

package/environments.d.ts

@@ -0,0 +1 @@
+export * from './dist/environments'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vitest",
   "type": "module",
-  "version": "0.25.8",
+  "version": "0.26.1",
   "description": "A blazing fast unit test framework powered by Vite",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -113,7 +113,8 @@
     "tinybench": "^2.3.1",
     "tinypool": "^0.3.0",
     "tinyspy": "^1.0.2",
-    "vite": "^3.0.0 || ^4.0.0"
+    "vite": "^3.0.0 || ^4.0.0",
+    "vite-node": "0.26.1"
   },
   "devDependencies": {
     "@antfu/install-pkg": "^0.1.1",
@@ -154,8 +155,7 @@
     "strip-ansi": "^7.0.1",
     "typescript": "^4.9.4",
     "ws": "^8.11.0",
-    "@vitest/ui": "0.25.8",
-    "vite-node": "0.25.8"
+    "@vitest/ui": "0.26.1"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",

package/dist/chunk-integrations-globals.4d261bb8.js

@@ -1,25 +0,0 @@
-import { m as globalApis } from './chunk-utils-env.03f840f2.js';
-import { i as index } from './chunk-runtime-test-state.3f86f48f.js';
-import 'tty';
-import 'url';
-import 'path';
-import './chunk-runtime-chain.f86e5250.js';
-import 'util';
-import 'chai';
-import './chunk-typecheck-constants.ed987901.js';
-import 'local-pkg';
-import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-runtime-rpc.42aebbb9.js';
-import './chunk-utils-timers.793fd179.js';
-import 'fs';
-import './chunk-utils-source-map.29ff1088.js';
-import './spy.js';
-import 'tinyspy';
-
-function registerApiGlobally() {
-  globalApis.forEach((api) => {
-    globalThis[api] = index[api];
-  });
-}
-
-export { registerApiGlobally };