vitest 0.17.1 → 0.19.0

package/dist/{vendor-entry.1ad8a08d.mjs → chunk-runtime-error.d82dd2cf.mjs}

@@ -1,35 +1,118 @@
-import { promises } from 'fs';
-import { v as isNode, a as getWorkerState, R as RealDate, h as safeClearTimeout, f as safeSetTimeout, F as toArray, Q as deepClone, O as getType, u as relative, S as partitionSuiteChildren, E as shuffle, T as hasTests, y as hasFailed, e as getFullName, k as resetModules } from './chunk-utils-global.4828c2e2.mjs';
-import { d as environments, t as takeCoverage, p as pLimit, f as envs } from './chunk-env-node.aa51c4cc.mjs';
-import { s as suite, t as test, d as describe, i as it, r as runOnce, a as isFirstRun, b as beforeAll, c as afterAll, e as beforeEach, f as afterEach, w as withCallback, g as createExpect, h as globalExpect, v as vitest, j as vi, k as getRunningMode, l as isWatchMode, m as resetRunOnceCounter, n as clearCollectorContext, o as defaultSuite, p as setHooks, q as getHooks, u as collectorContext, x as getSnapshotClient, y as setState, G as GLOBAL_EXPECT, z as getFn, A as getState } from './chunk-runtime-chain.6d23d202.mjs';
-import chai, { assert, should, util } from 'chai';
-import { r as rpc } from './chunk-runtime-rpc.d986adb9.mjs';
-import { format } from 'util';
-import { s as stringify } from './chunk-utils-source-map.a9047343.mjs';
+import { e as environments, t as takeCoverage, p as pLimit } from './chunk-defaults.408a0cfe.mjs';
+import { r as resetRunOnceCounter, i as index, v as vi } from './chunk-runtime-hooks.db398170.mjs';
+import { o as deepClone, q as getType, t as isNode, g as getWorkerState, R as RealDate, k as safeClearTimeout, s as safeSetTimeout, u as toArray, v as relativePath, x as isBrowser, y as partitionSuiteChildren, z as shuffle, A as hasTests, B as hasFailed, h as getFullName } from './chunk-utils-global.2aa95025.mjs';
+import { e as clearCollectorContext, f as defaultSuite, h as setHooks, j as getHooks, k as collectorContext, l as setState, G as GLOBAL_EXPECT, m as getFn, n as getState } from './chunk-runtime-chain.1e1aabb3.mjs';
+import { r as rpc } from './chunk-runtime-rpc.45d8ee19.mjs';
+import util$1 from 'util';
+import { util } from 'chai';
+import { s as stringify } from './chunk-utils-source-map.8b066ce2.mjs';
 
-var index = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  suite: suite,
-  test: test,
-  describe: describe,
-  it: it,
-  runOnce: runOnce,
-  isFirstRun: isFirstRun,
-  beforeAll: beforeAll,
-  afterAll: afterAll,
-  beforeEach: beforeEach,
-  afterEach: afterEach,
-  withCallback: withCallback,
-  assert: assert,
-  should: should,
-  createExpect: createExpect,
-  chai: chai,
-  expect: globalExpect,
-  vitest: vitest,
-  vi: vi,
-  getRunningMode: getRunningMode,
-  isWatchMode: isWatchMode
-});
+const OBJECT_PROTO = Object.getPrototypeOf({});
+function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
+  if (!val || typeof val === "string")
+    return val;
+  if (typeof val === "function")
+    return `Function<${val.name}>`;
+  if (typeof val !== "object")
+    return val;
+  if (val instanceof Promise || "then" in val || val.constructor && val.constructor.prototype === "AsyncFunction")
+    return "Promise";
+  if (typeof Element !== "undefined" && val instanceof Element)
+    return val.tagName;
+  if (typeof val.asymmetricMatch === "function")
+    return `${val.toString()} ${util$1.format(val.sample)}`;
+  if (seen.has(val))
+    return seen.get(val);
+  if (Array.isArray(val)) {
+    const clone = new Array(val.length);
+    seen.set(val, clone);
+    val.forEach((e, i) => {
+      clone[i] = serializeError(e, seen);
+    });
+    return clone;
+  } else {
+    const clone = /* @__PURE__ */ Object.create(null);
+    seen.set(val, clone);
+    let obj = val;
+    while (obj && obj !== OBJECT_PROTO) {
+      Object.getOwnPropertyNames(obj).forEach((key) => {
+        if (!(key in clone))
+          clone[key] = serializeError(obj[key], seen);
+      });
+      obj = Object.getPrototypeOf(obj);
+    }
+    return clone;
+  }
+}
+function normalizeErrorMessage(message) {
+  return message.replace(/__vite_ssr_import_\d+__\./g, "");
+}
+function processError(err) {
+  if (!err)
+    return err;
+  if (err.stack)
+    err.stackStr = String(err.stack);
+  if (err.name)
+    err.nameStr = String(err.name);
+  const clonedActual = deepClone(err.actual);
+  const clonedExpected = deepClone(err.expected);
+  const { replacedActual, replacedExpected } = replaceAsymmetricMatcher(clonedActual, clonedExpected);
+  err.actual = replacedActual;
+  err.expected = replacedExpected;
+  if (typeof err.expected !== "string")
+    err.expected = stringify(err.expected);
+  if (typeof err.actual !== "string")
+    err.actual = stringify(err.actual);
+  try {
+    if (typeof err.message === "string")
+      err.message = normalizeErrorMessage(err.message);
+    if (typeof err.cause === "object" && typeof err.cause.message === "string")
+      err.cause.message = normalizeErrorMessage(err.cause.message);
+  } catch {
+  }
+  try {
+    return serializeError(err);
+  } catch (e) {
+    return serializeError(new Error(`Failed to fully serialize error: ${e == null ? void 0 : e.message}
+Inner error message: ${err == null ? void 0 : err.message}`));
+  }
+}
+function isAsymmetricMatcher(data) {
+  const type = getType(data);
+  return type === "Object" && typeof data.asymmetricMatch === "function";
+}
+function isReplaceable(obj1, obj2) {
+  const obj1Type = getType(obj1);
+  const obj2Type = getType(obj2);
+  return obj1Type === obj2Type && obj1Type === "Object";
+}
+function replaceAsymmetricMatcher(actual, expected, actualReplaced = /* @__PURE__ */ new WeakMap(), expectedReplaced = /* @__PURE__ */ new WeakMap()) {
+  if (!isReplaceable(actual, expected))
+    return { replacedActual: actual, replacedExpected: expected };
+  if (actualReplaced.has(actual) || expectedReplaced.has(expected))
+    return { replacedActual: actual, replacedExpected: expected };
+  actualReplaced.set(actual, true);
+  expectedReplaced.set(expected, true);
+  util.getOwnEnumerableProperties(expected).forEach((key) => {
+    const expectedValue = expected[key];
+    const actualValue = actual[key];
+    if (isAsymmetricMatcher(expectedValue)) {
+      if (expectedValue.asymmetricMatch(actualValue))
+        actual[key] = expectedValue;
+    } else if (isAsymmetricMatcher(actualValue)) {
+      if (actualValue.asymmetricMatch(expectedValue))
+        expected[key] = actualValue;
+    } else if (isReplaceable(actualValue, expectedValue)) {
+      const replaced = replaceAsymmetricMatcher(actualValue, expectedValue, actualReplaced, expectedReplaced);
+      actual[key] = replaced.replacedActual;
+      expected[key] = replaced.replacedExpected;
+    }
+  });
+  return {
+    replacedActual: actual,
+    replacedExpected: expected
+  };
+}
 
 let globalSetup = false;
 async function setupGlobalEnv(config) {
@@ -45,7 +128,7 @@ async function setupGlobalEnv(config) {
   if (isNode)
     await setupConsoleLogSpy();
   if (config.globals)
-    (await import('./chunk-integrations-globals.3df36e26.mjs')).registerApiGlobally();
+    (await import('./chunk-integrations-globals.803277be.mjs')).registerApiGlobally();
 }
 function setupDefines(defines) {
   for (const key in defines)
@@ -173,113 +256,6 @@ async function runSetupFiles(config) {
   }));
 }
 
-const OBJECT_PROTO = Object.getPrototypeOf({});
-function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
-  if (!val || typeof val === "string")
-    return val;
-  if (typeof val === "function")
-    return `Function<${val.name}>`;
-  if (typeof val !== "object")
-    return val;
-  if (val instanceof Promise || "then" in val || val.constructor && val.constructor.prototype === "AsyncFunction")
-    return "Promise";
-  if (typeof Element !== "undefined" && val instanceof Element)
-    return val.tagName;
-  if (typeof val.asymmetricMatch === "function")
-    return `${val.toString()} ${format(val.sample)}`;
-  if (seen.has(val))
-    return seen.get(val);
-  if (Array.isArray(val)) {
-    const clone = new Array(val.length);
-    seen.set(val, clone);
-    val.forEach((e, i) => {
-      clone[i] = serializeError(e, seen);
-    });
-    return clone;
-  } else {
-    const clone = /* @__PURE__ */ Object.create(null);
-    seen.set(val, clone);
-    let obj = val;
-    while (obj && obj !== OBJECT_PROTO) {
-      Object.getOwnPropertyNames(obj).forEach((key) => {
-        if (!(key in clone))
-          clone[key] = serializeError(obj[key], seen);
-      });
-      obj = Object.getPrototypeOf(obj);
-    }
-    return clone;
-  }
-}
-function normalizeErrorMessage(message) {
-  return message.replace(/__vite_ssr_import_\d+__\./g, "");
-}
-function processError(err) {
-  if (!err)
-    return err;
-  if (err.stack)
-    err.stackStr = String(err.stack);
-  if (err.name)
-    err.nameStr = String(err.name);
-  const clonedActual = deepClone(err.actual);
-  const clonedExpected = deepClone(err.expected);
-  const { replacedActual, replacedExpected } = replaceAsymmetricMatcher(clonedActual, clonedExpected);
-  err.actual = replacedActual;
-  err.expected = replacedExpected;
-  if (typeof err.expected !== "string")
-    err.expected = stringify(err.expected);
-  if (typeof err.actual !== "string")
-    err.actual = stringify(err.actual);
-  try {
-    if (typeof err.message === "string")
-      err.message = normalizeErrorMessage(err.message);
-    if (typeof err.cause === "object" && err.cause.message === "string")
-      err.cause.message = normalizeErrorMessage(err.cause.message);
-  } catch {
-  }
-  try {
-    return serializeError(err);
-  } catch (e) {
-    return serializeError(new Error(`Failed to fully serialize error: ${e == null ? void 0 : e.message}
-Inner error message: ${err == null ? void 0 : err.message}`));
-  }
-}
-function isAsymmetricMatcher(data) {
-  const type = getType(data);
-  return type === "Object" && typeof data.asymmetricMatch === "function";
-}
-function isReplaceable(obj1, obj2) {
-  const obj1Type = getType(obj1);
-  const obj2Type = getType(obj2);
-  return obj1Type === obj2Type && obj1Type === "Object";
-}
-function replaceAsymmetricMatcher(actual, expected, actualReplaced = /* @__PURE__ */ new WeakMap(), expectedReplaced = /* @__PURE__ */ new WeakMap()) {
-  if (!isReplaceable(actual, expected))
-    return { replacedActual: actual, replacedExpected: expected };
-  if (actualReplaced.has(actual) || expectedReplaced.has(expected))
-    return { replacedActual: actual, replacedExpected: expected };
-  actualReplaced.set(actual, true);
-  expectedReplaced.set(expected, true);
-  util.getOwnEnumerableProperties(expected).forEach((key) => {
-    const expectedValue = expected[key];
-    const actualValue = actual[key];
-    if (isAsymmetricMatcher(expectedValue)) {
-      if (expectedValue.asymmetricMatch(actualValue))
-        actual[key] = expectedValue;
-    } else if (isAsymmetricMatcher(actualValue)) {
-      if (actualValue.asymmetricMatch(expectedValue))
-        expected[key] = actualValue;
-    } else if (isReplaceable(actualValue, expectedValue)) {
-      const replaced = replaceAsymmetricMatcher(actualValue, expectedValue, actualReplaced, expectedReplaced);
-      actual[key] = replaced.replacedActual;
-      expected[key] = replaced.replacedExpected;
-    }
-  });
-  return {
-    replacedActual: actual,
-    replacedExpected: expected
-  };
-}
-
 const now$1 = Date.now;
 function hash(str) {
   let hash2 = 0;
@@ -294,8 +270,17 @@ function hash(str) {
 }
 async function collectTests(paths, config) {
   const files = [];
+  const browserHashMap = getWorkerState().browserHashMap;
+  async function importFromBrowser(filepath) {
+    const match = filepath.match(/^(\w:\/)/);
+    const hash2 = browserHashMap.get(filepath);
+    if (match)
+      return await import(`/@fs/${filepath.slice(match[1].length)}?v=${hash2}`);
+    else
+      return await import(`${filepath}?v=${hash2}`);
+  }
   for (const filepath of paths) {
-    const path = relative(config.root, filepath);
+    const path = relativePath(config.root, filepath);
     const file = {
       id: hash(path),
       name: path,
@@ -307,7 +292,10 @@ async function collectTests(paths, config) {
     clearCollectorContext();
     try {
       await runSetupFiles(config);
-      await import(filepath);
+      if (config.browser && isBrowser)
+        await importFromBrowser(filepath);
+      else
+        await import(filepath);
       const defaultTasks = await defaultSuite.collect(file);
       setHooks(file, getHooks(defaultTasks));
       for (const c of [...defaultTasks.tasks, ...collectorContext.tasks]) {
@@ -328,6 +316,8 @@ async function collectTests(paths, config) {
         state: "fail",
         error: processError(e)
       };
+      if (config.browser)
+        console.error(e);
     }
     calculateHash(file);
     const hasOnlyTasks = someTasksAreOnly(file);
@@ -447,6 +437,7 @@ async function sendTasksUpdate() {
 async function runTest(test) {
   var _a, _b;
   if (test.mode !== "run") {
+    const { getSnapshotClient } = await import('./chunk-runtime-chain.1e1aabb3.mjs').then(function (n) { return n.p; });
     getSnapshotClient().skipTestSnapshots(test);
     return;
   }
@@ -461,7 +452,10 @@ async function runTest(test) {
   };
   updateTask(test);
   clearModuleMocks();
-  await getSnapshotClient().setTest(test);
+  if (isNode) {
+    const { getSnapshotClient } = await import('./chunk-runtime-chain.1e1aabb3.mjs').then(function (n) { return n.p; });
+    await getSnapshotClient().setTest(test);
+  }
   const workerState = getWorkerState();
   workerState.current = test;
   let beforeEachCleanups = [];
@@ -509,9 +503,14 @@ async function runTest(test) {
       test.result.error = void 0;
     }
   }
-  getSnapshotClient().clearTest();
+  if (isBrowser && test.result.error)
+    console.error(test.result.error.message, test.result.error.stackStr);
+  if (isNode) {
+    const { getSnapshotClient } = await import('./chunk-runtime-chain.1e1aabb3.mjs').then(function (n) { return n.p; });
+    getSnapshotClient().clearTest();
+  }
   test.result.duration = now() - start;
-  if (workerState.config.logHeapUsage)
+  if (workerState.config.logHeapUsage && isNode)
     test.result.heap = process.memoryUsage().heapUsed;
   workerState.current = void 0;
   updateTask(test);
@@ -570,7 +569,7 @@ async function runSuite(suite) {
     }
   }
   suite.result.duration = now() - start;
-  if (workerState.config.logHeapUsage)
+  if (workerState.config.logHeapUsage && isNode)
     suite.result.heap = process.memoryUsage().heapUsed;
   if (suite.mode === "run") {
     if (!hasTests(suite)) {
@@ -588,6 +587,10 @@ async function runSuite(suite) {
 async function runSuiteChild(c) {
   return c.type === "test" ? runTest(c) : runSuite(c);
 }
+async function runSuites(suites) {
+  for (const suite of suites)
+    await runSuite(suite);
+}
 async function runFiles(files, config) {
   var _a;
   for (const file of files) {
@@ -602,15 +605,32 @@ async function runFiles(files, config) {
     await runSuite(file);
   }
 }
-async function startTests(paths, config) {
+async function startTestsBrowser(paths, config) {
+  if (isNode) {
+    rpc().onPathsCollected(paths);
+  } else {
+    const files = await collectTests(paths, config);
+    await rpc().onCollected(files);
+    await runSuites(files);
+    await sendTasksUpdate();
+  }
+}
+async function startTestsNode(paths, config) {
   const files = await collectTests(paths, config);
   rpc().onCollected(files);
+  const { getSnapshotClient } = await import('./chunk-runtime-chain.1e1aabb3.mjs').then(function (n) { return n.p; });
   getSnapshotClient().clear();
   await runFiles(files, config);
   takeCoverage();
   await getSnapshotClient().saveCurrent();
   await sendTasksUpdate();
 }
+async function startTests(paths, config) {
+  if (config.browser)
+    return startTestsBrowser(paths, config);
+  else
+    return startTestsNode(paths, config);
+}
 function clearModuleMocks() {
   const { clearMocks, mockReset, restoreMocks } = getWorkerState().config;
   if (restoreMocks)
@@ -621,40 +641,4 @@ function clearModuleMocks() {
     vi.clearAllMocks();
 }
 
-async function run(files, config) {
-  await setupGlobalEnv(config);
-  const workerState = getWorkerState();
-  const filesWithEnv = await Promise.all(files.map(async (file) => {
-    var _a;
-    const code = await promises.readFile(file, "utf-8");
-    const env = ((_a = code.match(/@(?:vitest|jest)-environment\s+?([\w-]+)\b/)) == null ? void 0 : _a[1]) || config.environment || "node";
-    if (!envs.includes(env))
-      throw new Error(`Unsupported environment: "${env}" in ${file}`);
-    return {
-      file,
-      env
-    };
-  }));
-  const filesByEnv = filesWithEnv.reduce((acc, { file, env }) => {
-    acc[env] || (acc[env] = []);
-    acc[env].push(file);
-    return acc;
-  }, {});
-  for (const env of envs) {
-    const environment = env;
-    const files2 = filesByEnv[environment];
-    if (!files2 || !files2.length)
-      continue;
-    await withEnv(environment, config.environmentOptions || {}, async () => {
-      for (const file of files2) {
-        workerState.mockMap.clear();
-        resetModules();
-        workerState.filepath = file;
-        await startTests([file], config);
-        workerState.filepath = void 0;
-      }
-    });
-  }
-}
-
-export { index as i, run as r };
+export { setupGlobalEnv as a, startTests as s, withEnv as w };