vitest 0.25.7 → 0.26.0

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.96e022fd.js

@@ -0,0 +1,211 @@
+import 'acorn';
+import { builtinModules } from 'module';
+import 'fs';
+import { pathToFileURL } from 'url';
+import 'path';
+import assert from 'assert';
+import { format, inspect } from 'util';
+
+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/worker.js

@@ -1,25 +1,22 @@
 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.2b1f492a.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.bf08ae09.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.3f865d14.js';
+import { e as executeInViteNode } from './chunk-runtime-mocker.35fabb8b.js';
+import { r as rpc } from './chunk-runtime-rpc.7959fc79.js';
+import { p as processError } from './chunk-runtime-error.dfbbf9be.js';
 import 'tty';
 import 'url';
 import 'path';
-import 'module';
-import 'vm';
-import './chunk-vite-node-utils.0e4a6a88.js';
+import 'local-pkg';
+import 'vite';
 import 'fs';
+import './vendor-index.96e022fd.js';
 import 'acorn';
+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 'chai';
 
@@ -53,7 +50,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 +63,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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vitest",
   "type": "module",
-  "version": "0.25.7",
+  "version": "0.26.0",
   "description": "A blazing fast unit test framework powered by Vite",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -100,12 +100,12 @@
     }
   },
   "dependencies": {
-    "@types/chai": "^4.3.3",
+    "@types/chai": "^4.3.4",
     "@types/chai-subset": "^1.3.3",
     "@types/node": "*",
-    "acorn": "^8.8.0",
+    "acorn": "^8.8.1",
     "acorn-walk": "^8.2.0",
-    "chai": "^4.3.6",
+    "chai": "^4.3.7",
     "debug": "^4.3.4",
     "local-pkg": "^0.4.2",
     "source-map": "^0.6.1",
@@ -113,19 +113,19 @@
     "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.0"
   },
   "devDependencies": {
     "@antfu/install-pkg": "^0.1.1",
-    "@edge-runtime/vm": "2.0.1",
+    "@edge-runtime/vm": "2.0.2",
     "@sinonjs/fake-timers": "^10.0.0",
     "@types/diff": "^5.0.2",
-    "@types/jsdom": "^20.0.0",
+    "@types/jsdom": "^20.0.1",
     "@types/micromatch": "^4.0.2",
     "@types/natural-compare": "^1.4.1",
-    "@types/prompts": "^2.4.1",
+    "@types/prompts": "^2.4.2",
     "@types/sinonjs__fake-timers": "^8.1.2",
-    "@vitest/ui": "0.25.7",
     "birpc": "^0.2.3",
     "cac": "^6.7.14",
     "chai-subset": "^1.6.0",
@@ -138,10 +138,10 @@
     "find-up": "^6.3.0",
     "flatted": "^3.2.7",
     "get-tsconfig": "^4.2.0",
-    "happy-dom": "^7.6.6",
-    "jsdom": "^20.0.2",
+    "happy-dom": "^7.8.1",
+    "jsdom": "^20.0.3",
     "log-update": "^5.0.1",
-    "magic-string": "^0.26.7",
+    "magic-string": "^0.27.0",
     "micromatch": "^4.0.5",
     "mlly": "^1.0.0",
     "natural-compare": "^1.4.0",
@@ -153,9 +153,9 @@
     "prompts": "^2.4.2",
     "rollup": "^2.79.1",
     "strip-ansi": "^7.0.1",
-    "typescript": "^4.8.4",
-    "vite-node": "0.25.7",
-    "ws": "^8.11.0"
+    "typescript": "^4.9.4",
+    "ws": "^8.11.0",
+    "@vitest/ui": "0.26.0"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",