vitest 0.27.3 → 0.28.0

package/dist/chunk-utils-tasks.1b603032.js

@@ -0,0 +1,103 @@
+import { getNames, getTests } from '@vitest/runner/utils';
+import { resolve } from 'pathe';
+import { n as notNullish } from './chunk-utils-base.977ae74f.js';
+
+function hasFailedSnapshot(suite) {
+  return getTests(suite).some((s) => {
+    var _a, _b;
+    return (_b = (_a = s.result) == null ? void 0 : _a.errors) == null ? void 0 : _b.some((e) => e.message.match(/Snapshot .* mismatched/));
+  });
+}
+function getFullName(task, separator = " > ") {
+  return getNames(task).join(separator);
+}
+
+const lineSplitRE = /\r?\n/;
+const stackIgnorePatterns = [
+  "node:internal",
+  /\/packages\/\w+\/dist\//,
+  /\/@vitest\/\w+\/dist\//,
+  "/vitest/dist/",
+  "/vitest/src/",
+  "/vite-node/dist/",
+  "/vite-node/src/",
+  "/node_modules/chai/",
+  "/node_modules/tinypool/",
+  "/node_modules/tinyspy/"
+];
+function extractLocation(urlLike) {
+  if (!urlLike.includes(":"))
+    return [urlLike];
+  const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+  const parts = regExp.exec(urlLike.replace(/[()]/g, ""));
+  if (!parts)
+    return [urlLike];
+  return [parts[1], parts[2] || void 0, parts[3] || void 0];
+}
+function parseSingleStack(raw) {
+  let line = raw.trim();
+  if (line.includes("(eval "))
+    line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+  let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+  const location = sanitizedLine.match(/ (\(.+\)$)/);
+  sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+  const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
+  let method = location && sanitizedLine || "";
+  let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
+  if (!file || !lineNumber || !columnNumber)
+    return null;
+  if (method.startsWith("async "))
+    method = method.slice(6);
+  if (file.startsWith("file://"))
+    file = file.slice(7);
+  file = resolve(file);
+  return {
+    method,
+    file,
+    line: parseInt(lineNumber),
+    column: parseInt(columnNumber)
+  };
+}
+function parseStacktrace(e, full = false) {
+  if (!e)
+    return [];
+  if (e.stacks)
+    return e.stacks;
+  const stackStr = e.stack || e.stackStr || "";
+  const stackFrames = stackStr.split("\n").map((raw) => {
+    const stack = parseSingleStack(raw);
+    if (!stack || !full && stackIgnorePatterns.some((p) => stack.file.match(p)))
+      return null;
+    return stack;
+  }).filter(notNullish);
+  e.stacks = stackFrames;
+  return stackFrames;
+}
+function positionToOffset(source, lineNumber, columnNumber) {
+  const lines = source.split(lineSplitRE);
+  let start = 0;
+  if (lineNumber > lines.length)
+    return source.length;
+  for (let i = 0; i < lineNumber - 1; i++)
+    start += lines[i].length + 1;
+  return start + columnNumber;
+}
+function offsetToLineNumber(source, offset) {
+  if (offset > source.length) {
+    throw new Error(
+      `offset is longer than source length! offset ${offset} > length ${source.length}`
+    );
+  }
+  const lines = source.split(lineSplitRE);
+  let counted = 0;
+  let line = 0;
+  for (; line < lines.length; line++) {
+    const lineLength = lines[line].length + 1;
+    if (counted + lineLength >= offset)
+      break;
+    counted += lineLength;
+  }
+  return line + 1;
+}
+
+export { parseStacktrace as a, parseSingleStack as b, getFullName as g, hasFailedSnapshot as h, lineSplitRE as l, offsetToLineNumber as o, positionToOffset as p };

package/dist/cli-wrapper.js

@@ -1,24 +1,25 @@
 import { fileURLToPath } from 'url';
 import c from 'picocolors';
-import { e as execa } from './vendor-index.451e37bc.js';
-import { E as EXIT_CODE_RESTART } from './chunk-utils-env.4ebb0106.js';
+import { e as execa } from './vendor-index.618ca5a1.js';
+import { E as EXIT_CODE_RESTART } from './chunk-constants.797d3ebf.js';
 import 'node:buffer';
 import 'node:path';
 import 'node:child_process';
 import 'node:process';
-import './vendor-index.e6c27006.js';
 import 'child_process';
 import 'path';
 import './vendor-_commonjsHelpers.addc3445.js';
 import 'fs';
+import 'node:url';
+import 'os';
+import 'node:os';
 import 'assert';
 import 'events';
 import 'buffer';
 import 'stream';
 import 'util';
-import 'node:url';
-import 'os';
-import 'node:os';
+import 'pathe';
+import './chunk-utils-env.860d90c2.js';
 import 'std-env';
 
 const ENTRY = new URL("./cli.js", import.meta.url);

package/dist/cli.js

@@ -1,37 +1,39 @@
-import { n as normalize } from './chunk-utils-env.4ebb0106.js';
+import { normalize } from 'pathe';
 import cac from 'cac';
 import c from 'picocolors';
-import { v as version, s as startVitest, d as divider } from './chunk-snapshot-manager.d16903ef.js';
+import { v as version, s as startVitest, d as divider } from './chunk-node-pkg.dcdf4369.js';
+import './chunk-constants.797d3ebf.js';
 import 'node:url';
-import 'path';
+import './chunk-utils-env.860d90c2.js';
 import 'std-env';
-import './chunk-integrations-coverage.18366936.js';
+import './chunk-integrations-coverage.48e6286b.js';
 import 'local-pkg';
+import 'util';
+import 'path';
 import './chunk-env-node.ffd1183b.js';
 import 'node:console';
-import './chunk-mock-date.91595ccd.js';
-import 'node:path';
 import 'vite';
+import 'node:path';
 import 'node:process';
 import 'node:fs';
 import 'os';
-import './vendor-index.57682f0c.js';
-import 'util';
 import 'stream';
 import 'events';
 import 'fs';
 import './vendor-_commonjsHelpers.addc3445.js';
 import 'vite-node/client';
 import 'vite-node/server';
+import './chunk-utils-global.442d1d33.js';
+import '@vitest/runner/utils';
+import '@vitest/utils';
 import 'node:fs/promises';
-import './vendor-index.451e37bc.js';
+import './vendor-index.618ca5a1.js';
 import 'node:buffer';
 import 'node:child_process';
-import './vendor-index.e6c27006.js';
 import 'child_process';
+import 'node:os';
 import 'assert';
 import 'buffer';
-import 'node:os';
 import 'source-map';
 import 'module';
 import 'acorn';
@@ -40,16 +42,15 @@ import 'node:worker_threads';
 import 'tinypool';
 import './vendor-index.783e7f3e.js';
 import 'perf_hooks';
-import './chunk-utils-source-map.832515f7.js';
-import './chunk-utils-timers.52534f96.js';
+import './chunk-utils-base.977ae74f.js';
+import './chunk-utils-tasks.1b603032.js';
 import 'crypto';
 import 'vite-node/utils';
-import './vendor-index.9c919048.js';
+import '@vitest/utils/diff';
 import 'node:crypto';
 import './chunk-magic-string.3a794426.js';
 import 'strip-literal';
 import 'readline';
-import './vendor-index.9f20a9be.js';
 
 const cli = cac("vitest");
 cli.version(version).option("-r, --root <path>", "Root path").option("-c, --config <path>", "Path to config file").option("-u, --update", "Update snapshot").option("-w, --watch", "Enable watch mode").option("-t, --testNamePattern <pattern>", "Run tests with full names matching the specified regexp pattern").option("--dir <path>", "Base directory to scan for the test files").option("--ui", "Enable UI").option("--open", "Open UI automatically (default: !process.env.CI))").option("--api [api]", "Serve API, available options: --api.port <port>, --api.host [host] and --api.strictPort").option("--threads", "Enabled threads (default: true)").option("--silent", "Silent console output from tests").option("--isolate", "Isolate environment for each test file (default: true)").option("--reporter <name>", "Specify reporters").option("--outputDiffMaxSize <length>", "Object diff output max size (default: 10000)").option("--outputDiffMaxLines <length>", "Max lines in diff output window (default: 50)").option("--outputTruncateLength <length>", "Diff output line length (default: 80)").option("--outputDiffLines <lines>", "Number of lines in single diff (default: 15)").option("--outputFile <filename/-s>", "Write test results to a file when supporter reporter is also specified, use cac's dot notation for individual outputs of multiple reporters").option("--coverage", "Enable coverage report").option("--run", "Disable watch mode").option("--mode <name>", "Override Vite mode (default: test)").option("--globals", "Inject apis globally").option("--dom", "Mock browser api with happy-dom").option("--browser", "Run tests in browser").option("--environment <env>", "Specify runner environment (default: node)").option("--passWithNoTests", "Pass when no tests found").option("--logHeapUsage", "Show the size of heap for each test").option("--allowOnly", "Allow tests and suites that are marked as only (default: !process.env.CI)").option("--dangerouslyIgnoreUnhandledErrors", "Ignore any unhandled errors that occur").option("--shard <shard>", "Test suite shard to execute in a format of <index>/<count>").option("--changed [since]", "Run tests that are affected by the changed files (default: false)").option("--sequence <options>", "Define in what order to run tests (use --sequence.shuffle to run tests in random order)").option("--segfaultRetry <times>", "Return tests on segment fault (default: 0)", { default: 0 }).option("--no-color", "Removes colors from the console output").option("--inspect", "Enable Node.js inspector").option("--inspect-brk", "Enable Node.js inspector with break").help();

package/dist/config.d.ts

@@ -1,12 +1,17 @@
 import { UserConfig as UserConfig$2, ConfigEnv } from 'vite';
 export { ConfigEnv } from 'vite';
-import { ao as ResolvedCoverageOptions, U as UserConfig$1, ar as CoverageC8Options, al as CoverageProviderModule, ap as BaseCoverageOptions, aq as CoverageIstanbulOptions, am as CoverageReporter, F as FakeTimerInstallOpts } from './types-c1386a7d.js';
+import { a1 as ResolvedCoverageOptions, U as UserConfig$1, a4 as CoverageC8Options, _ as CoverageProviderModule, a2 as BaseCoverageOptions, a3 as CoverageIstanbulOptions, $ as CoverageReporter, F as FakeTimerInstallOpts } from './types-c800444e.js';
+import '@vitest/expect';
+import '@vitest/runner/types';
+import '@vitest/runner';
+import '@vitest/runner/utils';
+import '@vitest/utils';
 import 'tinybench';
 import 'vite-node/client';
 import 'vite-node/server';
+import 'node:worker_threads';
 import 'vite-node';
 import 'node:fs';
-import 'node:worker_threads';
 
 declare const defaultInclude: string[];
 declare const defaultExclude: string[];

package/dist/entry.js

@@ -1,31 +1,206 @@
-import { promises } from 'node:fs';
-import { m as micromatch_1 } from './vendor-index.57682f0c.js';
-import { g as getWorkerState, a as resetModules } from './chunk-mock-date.91595ccd.js';
-import { v as vi } from './chunk-utils-import.eb63557e.js';
-import { a as envs } from './chunk-env-node.ffd1183b.js';
-import { a as setupGlobalEnv, s as startTests, w as withEnv } from './chunk-runtime-setup.8ca273cd.js';
+import { promises, existsSync } from 'node:fs';
+import { m as micromatch_1, t as takeCoverageInsideWorker } from './chunk-integrations-coverage.48e6286b.js';
+import { startTests } from '@vitest/runner';
+import { g as getWorkerState, r as resetModules } from './chunk-utils-global.442d1d33.js';
+import { R as RealDate, g as globalExpect, a as vi } from './chunk-utils-import.9911c99d.js';
+import { e as environments, a as envs } from './chunk-env-node.ffd1183b.js';
+import { createRequire } from 'node:module';
+import c from 'picocolors';
+import { installSourcemapsSupport } from 'vite-node/source-map';
+import { setColors, getSafeTimers } from '@vitest/utils';
+import { i as index } from './chunk-integrations-utils.f1f6f1ed.js';
+import { s as setupSnapshotEnvironment } from './chunk-snapshot-env.6457638e.js';
+import { r as rpc } from './chunk-runtime-rpc.9c0386cc.js';
+import { s as setupCommonEnv } from './chunk-runtime-setup.d9302cfd.js';
+import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './runners-chunk.js';
+import 'local-pkg';
 import 'util';
 import 'path';
-import 'node:path';
-import 'picocolors';
-import 'local-pkg';
-import './chunk-utils-env.4ebb0106.js';
-import 'node:url';
+import 'pathe';
+import './chunk-utils-env.860d90c2.js';
 import 'std-env';
-import './chunk-runtime-chain.07d16eac.js';
+import '@vitest/runner/utils';
 import 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-utils-timers.52534f96.js';
-import './vendor-index.723a074f.js';
-import 'tinyspy';
-import './chunk-utils-source-map.832515f7.js';
-import './chunk-runtime-rpc.e79efa9a.js';
-import 'fs';
+import '@vitest/expect';
+import './chunk-utils-base.977ae74f.js';
+import './chunk-utils-tasks.1b603032.js';
+import '@vitest/spy';
 import 'node:console';
-import 'perf_hooks';
-import './chunk-integrations-coverage.18366936.js';
-import './chunk-runtime-error.f2062967.js';
-import 'vite-node/source-map';
+import './chunk-integrations-run-once.38756e30.js';
+
+class NodeSnapshotEnvironment {
+  resolvePath(filepath) {
+    return rpc().resolveSnapshotPath(filepath);
+  }
+  async prepareDirectory(filepath) {
+    await promises.mkdir(filepath, { recursive: true });
+  }
+  async saveSnapshotFile(filepath, snapshot) {
+    await promises.writeFile(filepath, snapshot, "utf-8");
+  }
+  async readSnapshotFile(filepath) {
+    if (!existsSync(filepath))
+      return null;
+    return promises.readFile(filepath, "utf-8");
+  }
+  async removeSnapshotFile(filepath) {
+    if (existsSync(filepath))
+      await promises.unlink(filepath);
+  }
+}
+
+let globalSetup = false;
+async function setupGlobalEnv(config) {
+  await setupCommonEnv(config);
+  Object.defineProperty(globalThis, "__vitest_index__", {
+    value: index,
+    enumerable: false
+  });
+  if (globalSetup)
+    return;
+  globalSetup = true;
+  setupSnapshotEnvironment(new NodeSnapshotEnvironment());
+  setColors(c);
+  const require = createRequire(import.meta.url);
+  require.extensions[".css"] = () => ({});
+  require.extensions[".scss"] = () => ({});
+  require.extensions[".sass"] = () => ({});
+  const state = getWorkerState();
+  installSourcemapsSupport({
+    getSourceMap: (source) => state.moduleCache.getSourceMap(source)
+  });
+  await setupConsoleLogSpy();
+}
+async function setupConsoleLogSpy() {
+  const stdoutBuffer = /* @__PURE__ */ new Map();
+  const stderrBuffer = /* @__PURE__ */ new Map();
+  const timers = /* @__PURE__ */ new Map();
+  const unknownTestId = "__vitest__unknown_test__";
+  const { Writable } = await import('node:stream');
+  const { Console } = await import('node:console');
+  const { setTimeout, clearTimeout } = getSafeTimers();
+  function schedule(taskId) {
+    const timer = timers.get(taskId);
+    const { stdoutTime, stderrTime } = timer;
+    clearTimeout(timer.timer);
+    timer.timer = setTimeout(() => {
+      if (stderrTime < stdoutTime) {
+        sendStderr(taskId);
+        sendStdout(taskId);
+      } else {
+        sendStdout(taskId);
+        sendStderr(taskId);
+      }
+    });
+  }
+  function sendStdout(taskId) {
+    const buffer = stdoutBuffer.get(taskId);
+    if (!buffer)
+      return;
+    const content = buffer.map((i) => String(i)).join("");
+    if (!content.trim())
+      return;
+    const timer = timers.get(taskId);
+    rpc().onUserConsoleLog({
+      type: "stdout",
+      content,
+      taskId,
+      time: timer.stdoutTime || RealDate.now(),
+      size: buffer.length
+    });
+    stdoutBuffer.set(taskId, []);
+    timer.stdoutTime = 0;
+  }
+  function sendStderr(taskId) {
+    const buffer = stderrBuffer.get(taskId);
+    if (!buffer)
+      return;
+    const content = buffer.map((i) => String(i)).join("");
+    if (!content.trim())
+      return;
+    const timer = timers.get(taskId);
+    rpc().onUserConsoleLog({
+      type: "stderr",
+      content,
+      taskId,
+      time: timer.stderrTime || RealDate.now(),
+      size: buffer.length
+    });
+    stderrBuffer.set(taskId, []);
+    timer.stderrTime = 0;
+  }
+  const stdout = new Writable({
+    write(data, encoding, callback) {
+      var _a, _b;
+      const id = ((_b = (_a = getWorkerState()) == null ? void 0 : _a.current) == null ? void 0 : _b.id) ?? unknownTestId;
+      let timer = timers.get(id);
+      if (timer) {
+        timer.stdoutTime = timer.stdoutTime || RealDate.now();
+      } else {
+        timer = { stdoutTime: RealDate.now(), stderrTime: RealDate.now(), timer: 0 };
+        timers.set(id, timer);
+      }
+      let buffer = stdoutBuffer.get(id);
+      if (!buffer) {
+        buffer = [];
+        stdoutBuffer.set(id, buffer);
+      }
+      buffer.push(data);
+      schedule(id);
+      callback();
+    }
+  });
+  const stderr = new Writable({
+    write(data, encoding, callback) {
+      var _a, _b;
+      const id = ((_b = (_a = getWorkerState()) == null ? void 0 : _a.current) == null ? void 0 : _b.id) ?? unknownTestId;
+      let timer = timers.get(id);
+      if (timer) {
+        timer.stderrTime = timer.stderrTime || RealDate.now();
+      } else {
+        timer = { stderrTime: RealDate.now(), stdoutTime: RealDate.now(), timer: 0 };
+        timers.set(id, timer);
+      }
+      let buffer = stderrBuffer.get(id);
+      if (!buffer) {
+        buffer = [];
+        stderrBuffer.set(id, buffer);
+      }
+      buffer.push(data);
+      schedule(id);
+      callback();
+    }
+  });
+  globalThis.console = new Console({
+    stdout,
+    stderr,
+    colorMode: true,
+    groupIndentation: 2
+  });
+}
+async function loadEnvironment(name) {
+  const pkg = await import(`vitest-environment-${name}`);
+  if (!pkg || !pkg.default || typeof pkg.default !== "object" || typeof pkg.default.setup !== "function") {
+    throw new Error(
+      `Environment "${name}" is not a valid environment. Package "vitest-environment-${name}" should have default export with "setup" method.`
+    );
+  }
+  return pkg.default;
+}
+async function withEnv(name, options, fn) {
+  const config = environments[name] || await loadEnvironment(name);
+  globalThis.__vitest_environment__ = config.name || name;
+  globalExpect.setState({
+    environment: config.name || name || "node"
+  });
+  const env = await config.setup(globalThis, options);
+  try {
+    await fn();
+  } finally {
+    await env.teardown(globalThis);
+  }
+}
 
 function groupBy(collection, iteratee) {
   return collection.reduce((acc, item) => {
@@ -35,14 +210,44 @@ function groupBy(collection, iteratee) {
     return acc;
   }, {});
 }
+async function getTestRunnerConstructor(config) {
+  if (!config.runner)
+    return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
+  const mod = await import(config.runner);
+  if (!mod.default && typeof mod.default !== "function")
+    throw new Error(`Runner must export a default function, but got ${typeof mod.default} imported from ${config.runner}`);
+  return mod.default;
+}
+async function getTestRunner(config) {
+  const TestRunner = await getTestRunnerConstructor(config);
+  const testRunner = new TestRunner(config);
+  if (!testRunner.config)
+    testRunner.config = config;
+  if (!testRunner.importFile)
+    throw new Error('Runner must implement "importFile" method.');
+  const originalOnTaskUpdate = testRunner.onTaskUpdate;
+  testRunner.onTaskUpdate = async (task) => {
+    const p = rpc().onTaskUpdate(task);
+    await (originalOnTaskUpdate == null ? void 0 : originalOnTaskUpdate.call(testRunner, task));
+    return p;
+  };
+  const originalOnCollected = testRunner.onCollected;
+  testRunner.onCollected = async (files) => {
+    rpc().onCollected(files);
+    await (originalOnCollected == null ? void 0 : originalOnCollected.call(testRunner, files));
+  };
+  const originalOnAfterRun = testRunner.onAfterRun;
+  testRunner.onAfterRun = async (files) => {
+    const coverage = await takeCoverageInsideWorker(config.coverage);
+    rpc().onAfterSuiteRun({ coverage });
+    await (originalOnAfterRun == null ? void 0 : originalOnAfterRun.call(testRunner, files));
+  };
+  return testRunner;
+}
 async function run(files, config) {
   await setupGlobalEnv(config);
   const workerState = getWorkerState();
-  if (config.browser) {
-    workerState.mockMap.clear();
-    await startTests(files, config);
-    return;
-  }
+  const runner = await getTestRunner(config);
   const filesWithEnv = await Promise.all(files.map(async (file) => {
     var _a, _b;
     const code = await promises.readFile(file, "utf-8");
@@ -85,7 +290,7 @@ async function run(files, config) {
             resetModules(workerState.moduleCache, true);
           }
           workerState.filepath = file;
-          await startTests([file], config);
+          await startTests([file], runner);
           workerState.filepath = void 0;
           vi.resetConfig();
         }

package/dist/env-afee91f0.d.ts

@@ -0,0 +1,10 @@
+interface SnapshotEnvironment {
+    resolvePath(filepath: string): Promise<string>;
+    prepareDirectory(filepath: string): Promise<void>;
+    saveSnapshotFile(filepath: string, snapshot: string): Promise<void>;
+    readSnapshotFile(filepath: string): Promise<string | null>;
+    removeSnapshotFile(filepath: string): Promise<void>;
+}
+declare function setupSnapshotEnvironment(environment: SnapshotEnvironment): void;
+
+export { SnapshotEnvironment as S, setupSnapshotEnvironment as s };

package/dist/environments.d.ts

@@ -1,11 +1,16 @@
-import { ae as Environment } from './types-c1386a7d.js';
+import { P as Environment } from './types-c800444e.js';
+import '@vitest/expect';
 import 'vite';
+import '@vitest/runner/types';
+import '@vitest/runner';
+import '@vitest/runner/utils';
+import '@vitest/utils';
 import 'tinybench';
 import 'vite-node/client';
 import 'vite-node/server';
+import 'node:worker_threads';
 import 'vite-node';
 import 'node:fs';
-import 'node:worker_threads';
 
 declare const environments: {
     node: Environment;