vitest 0.27.2 → 0.28.0

package/dist/{chunk-runtime-mocker.58511c38.js → chunk-runtime-mocker.03017e8c.js}

@@ -1,11 +1,13 @@
 import { ViteNodeRunner } from 'vite-node/client';
 import { isInternalRequest } from 'vite-node/utils';
 import { normalizePath } from 'vite';
-import { i as isNodeBuiltin } from './vendor-index.b0346fe4.js';
-import { g as getWorkerState, x as getType, I as getAllMockableProperties, d as getCurrentEnvironment } from './chunk-mock-date.c543fa3e.js';
+import { i as isNodeBuiltin } from './vendor-index.bdee400f.js';
+import { g as getWorkerState, b as getCurrentEnvironment } from './chunk-utils-global.442d1d33.js';
 import { existsSync, readdirSync } from 'node:fs';
-import { b as resolve, f as distDir, h as isAbsolute, d as dirname, j as join, c as basename, e as extname } from './chunk-utils-env.f4a39d2c.js';
-import c from 'picocolors';
+import { resolve, isAbsolute, dirname, join, basename, extname } from 'pathe';
+import { getColors } from '@vitest/utils';
+import { d as distDir } from './chunk-constants.797d3ebf.js';
+import { g as getType, c as getAllMockableProperties } from './chunk-utils-base.977ae74f.js';
 
 class RefTracker {
   constructor() {
@@ -102,6 +104,7 @@ const _VitestMocker = class {
           if (target instanceof Promise)
             return target.then.bind(target);
         } else if (!(prop in target)) {
+          const c = getColors();
           throw new Error(
             `[vitest] No "${String(prop)}" export is defined on the "${mockpath}" mock. Did you forget to return it from "vi.mock"?
 If you need to partially mock a module, you can use "vi.importActual" inside:
@@ -309,12 +312,17 @@ class VitestRunner extends ViteNodeRunner {
     super(options);
     this.options = options;
     this.mocker = new VitestMocker(this);
+    Object.defineProperty(globalThis, "__vitest_mocker__", {
+      value: this.mocker,
+      writable: true,
+      configurable: true
+    });
   }
   shouldResolveId(id, _importee) {
     if (isInternalRequest(id))
       return false;
     const environment = getCurrentEnvironment();
-    return environment === "node" ? !isNodeBuiltin(id) : true;
+    return environment === "node" ? !isNodeBuiltin(id) : !id.startsWith("node:");
   }
   async resolveUrl(id, importee) {
     if (importee && importee.startsWith("mock:"))
@@ -334,14 +342,7 @@ class VitestRunner extends ViteNodeRunner {
     if (workerState.filepath && normalizePath(workerState.filepath) === normalizePath(context.__filename)) {
       Object.defineProperty(context.__vite_ssr_import_meta__, "vitest", { get: () => globalThis.__vitest_index__ });
     }
-    return Object.assign(context, {
-      __vitest_mocker__: this.mocker
-    });
-  }
-  shouldInterop(path, mod) {
-    if (this.options.interopDefault === false)
-      return false;
-    return (this.options.interopDefault || getCurrentEnvironment() !== "node") && super.shouldInterop(path, mod);
+    return context;
   }
 }
 

package/dist/{chunk-runtime-rpc.d709e91b.js → chunk-runtime-rpc.9c0386cc.js}

@@ -1,8 +1,9 @@
-import { g as getWorkerState } from './chunk-mock-date.c543fa3e.js';
-import { s as safeSetTimeout } from './chunk-utils-timers.52534f96.js';
+import { getSafeTimers } from '@vitest/utils';
+import { g as getWorkerState } from './chunk-utils-global.442d1d33.js';
 
 const safeRandom = Math.random;
 function withSafeTimers(fn) {
+  const { setTimeout: safeSetTimeout } = getSafeTimers();
   const currentSetTimeout = globalThis.setTimeout;
   const currentRandom = globalThis.Math.random;
   try {

package/dist/chunk-runtime-setup.d9302cfd.js

@@ -0,0 +1,20 @@
+import { setSafeTimers } from '@vitest/utils';
+import { a as resetRunOnceCounter } from './chunk-integrations-run-once.38756e30.js';
+
+let globalSetup = false;
+async function setupCommonEnv(config) {
+  resetRunOnceCounter();
+  setupDefines(config.defines);
+  if (globalSetup)
+    return;
+  globalSetup = true;
+  setSafeTimers();
+  if (config.globals)
+    (await import('./chunk-integrations-globals.0d5f50f0.js')).registerApiGlobally();
+}
+function setupDefines(defines) {
+  for (const key in defines)
+    globalThis[key] = defines[key];
+}
+
+export { setupCommonEnv as s };

package/dist/chunk-snapshot-env.6457638e.js

@@ -0,0 +1,11 @@
+let _snapshotEnvironment;
+function setupSnapshotEnvironment(environment) {
+  _snapshotEnvironment = environment;
+}
+function getSnapshotEnironment() {
+  if (!_snapshotEnvironment)
+    throw new Error("Snapshot environment is not setup");
+  return _snapshotEnvironment;
+}
+
+export { getSnapshotEnironment as g, setupSnapshotEnvironment as s };

package/dist/chunk-utils-base.977ae74f.js

@@ -0,0 +1,77 @@
+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 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 notNullish(v) {
+  return v != null;
+}
+function slash(str) {
+  return str.replace(/\\/g, "/");
+}
+const noop = () => {
+};
+function getType(value) {
+  return Object.prototype.toString.apply(value).slice(8, -1);
+}
+function toArray(array) {
+  if (array === null || array === void 0)
+    array = [];
+  if (Array.isArray(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 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;
+}
+
+export { noop as a, stdout as b, getAllMockableProperties as c, deepMerge as d, getType as g, isObject as i, notNullish as n, slash as s, toArray as t };

package/dist/chunk-utils-env.860d90c2.js

@@ -0,0 +1,6 @@
+import 'std-env';
+
+var _a;
+const isNode = typeof process < "u" && typeof process.stdout < "u" && !((_a = process.versions) == null ? void 0 : _a.deno) && !globalThis.window;
+
+export { isNode as i };

package/dist/chunk-utils-global.442d1d33.js

@@ -0,0 +1,73 @@
+import { relative } from 'pathe';
+import { i as isNode } from './chunk-utils-env.860d90c2.js';
+import '@vitest/runner/utils';
+import '@vitest/utils';
+
+function getWorkerState() {
+  return globalThis.__vitest_worker__;
+}
+function getCurrentEnvironment() {
+  return globalThis.__vitest_environment__;
+}
+
+const isWindows = isNode && process.platform === "win32";
+const getRunMode = () => getWorkerState().config.mode;
+const isRunningInBenchmark = () => getRunMode() === "benchmark";
+const relativePath = relative;
+function resetModules(modules, resetMocks = false) {
+  const skipPaths = [
+    /\/vitest\/dist\//,
+    /\/vite-node\/dist\//,
+    /vitest-virtual-\w+\/dist/,
+    /@vitest\/dist/,
+    ...!resetMocks ? [/^mock:/] : []
+  ];
+  modules.forEach((_, path) => {
+    if (skipPaths.some((re) => re.test(path)))
+      return;
+    modules.delete(path);
+  });
+}
+function removeUndefinedValues(obj) {
+  for (const key in Object.keys(obj)) {
+    if (obj[key] === void 0)
+      delete obj[key];
+  }
+  return obj;
+}
+function getCallLastIndex(code) {
+  let charIndex = -1;
+  let inString = null;
+  let startedBracers = 0;
+  let endedBracers = 0;
+  let beforeChar = null;
+  while (charIndex <= code.length) {
+    beforeChar = code[charIndex];
+    charIndex++;
+    const char = code[charIndex];
+    const isCharString = char === '"' || char === "'" || char === "`";
+    if (isCharString && beforeChar !== "\\") {
+      if (inString === char)
+        inString = null;
+      else if (!inString)
+        inString = char;
+    }
+    if (!inString) {
+      if (char === "(")
+        startedBracers++;
+      if (char === ")")
+        endedBracers++;
+    }
+    if (startedBracers && endedBracers && startedBracers === endedBracers)
+      return charIndex;
+  }
+  return null;
+}
+class AggregateErrorPonyfill extends Error {
+  constructor(errors, message = "") {
+    super(message);
+    this.errors = [...errors];
+  }
+}
+
+export { AggregateErrorPonyfill as A, getCallLastIndex as a, getCurrentEnvironment as b, relativePath as c, removeUndefinedValues as d, isWindows as e, getWorkerState as g, isRunningInBenchmark as i, resetModules as r };