vitest 0.32.4 → 0.34.0

package/dist/{vendor-global.6795f91f.js → vendor-global.97e4527c.js}

@@ -2,7 +2,8 @@ function getWorkerState() {
   return globalThis.__vitest_worker__;
 }
 function getCurrentEnvironment() {
-  return globalThis.__vitest_environment__;
+  const state = getWorkerState();
+  return state == null ? void 0 : state.environment.name;
 }
 
 export { getCurrentEnvironment as a, getWorkerState as g };

package/dist/{vendor-index.23ac4e13.js → vendor-index.087d1af7.js}

@@ -2,7 +2,7 @@ import { relative } from 'pathe';
 import 'std-env';
 import '@vitest/runner/utils';
 import '@vitest/utils';
-import { g as getWorkerState } from './vendor-global.6795f91f.js';
+import { g as getWorkerState } from './vendor-global.97e4527c.js';
 
 var _a;
 const isNode = typeof process < "u" && typeof process.stdout < "u" && !((_a = process.versions) == null ? void 0 : _a.deno) && !globalThis.window;
@@ -15,24 +15,6 @@ function isRunningInBenchmark() {
   return getRunMode() === "benchmark";
 }
 const relativePath = relative;
-function resetModules(modules, resetMocks = false) {
-  const skipPaths = [
-    // Vitest
-    /\/vitest\/dist\//,
-    /\/vite-node\/dist\//,
-    // yarn's .store folder
-    /vitest-virtual-\w+\/dist/,
-    // cnpm
-    /@vitest\/dist/,
-    // don't clear mocks
-    ...!resetMocks ? [/^mock:/] : []
-  ];
-  modules.forEach((mod, path) => {
-    if (skipPaths.some((re) => re.test(path)))
-      return;
-    modules.invalidateModule(mod);
-  });
-}
 function removeUndefinedValues(obj) {
   for (const key in Object.keys(obj)) {
     if (obj[key] === void 0)
@@ -41,4 +23,4 @@ function removeUndefinedValues(obj) {
   return obj;
 }
 
-export { isNode as a, relativePath as b, removeUndefinedValues as c, isWindows as d, isRunningInBenchmark as i, resetModules as r };
+export { isNode as a, removeUndefinedValues as b, isWindows as c, isRunningInBenchmark as i, relativePath as r };

package/dist/vendor-index.9378c9a4.js

@@ -0,0 +1,89 @@
+import * as chai from 'chai';
+import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
+import { resolve } from 'pathe';
+import { d as distDir } from './vendor-paths.84fc7a99.js';
+import { g as getWorkerState } from './vendor-global.97e4527c.js';
+import { a as rpc } from './vendor-rpc.cbd8e972.js';
+import { t as takeCoverageInsideWorker } from './vendor-coverage.78040316.js';
+
+function setupChaiConfig(config) {
+  Object.assign(chai.config, config);
+}
+
+class VitestSnapshotEnvironment extends NodeSnapshotEnvironment {
+  constructor(rpc) {
+    super();
+    this.rpc = rpc;
+  }
+  getHeader() {
+    return `// Vitest Snapshot v${this.getVersion()}, https://vitest.dev/guide/snapshot.html`;
+  }
+  resolvePath(filepath) {
+    return this.rpc.resolveSnapshotPath(filepath);
+  }
+}
+
+const runnersFile = resolve(distDir, "runners.js");
+async function getTestRunnerConstructor(config, executor) {
+  if (!config.runner) {
+    const { VitestTestRunner, NodeBenchmarkRunner } = await executor.executeFile(runnersFile);
+    return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
+  }
+  const mod = await executor.executeId(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 resolveTestRunner(config, executor) {
+  const TestRunner = await getTestRunnerConstructor(config, executor);
+  const testRunner = new TestRunner(config);
+  Object.defineProperty(testRunner, "__vitest_executor", {
+    value: executor,
+    enumerable: false,
+    configurable: false
+  });
+  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) => {
+    const state = getWorkerState();
+    files.forEach((file) => {
+      file.prepareDuration = state.durations.prepare;
+      file.environmentLoad = state.durations.environment;
+      state.durations.prepare = 0;
+      state.durations.environment = 0;
+    });
+    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, executor);
+    rpc().onAfterSuiteRun({ coverage });
+    await (originalOnAfterRun == null ? void 0 : originalOnAfterRun.call(testRunner, files));
+  };
+  const originalOnAfterRunTest = testRunner.onAfterRunTest;
+  testRunner.onAfterRunTest = async (test) => {
+    var _a, _b;
+    if (config.bail && ((_a = test.result) == null ? void 0 : _a.state) === "fail") {
+      const previousFailures = await rpc().getCountOfFailedTests();
+      const currentFailures = 1 + previousFailures;
+      if (currentFailures >= config.bail) {
+        rpc().onCancel("test-failure");
+        (_b = testRunner.onCancel) == null ? void 0 : _b.call(testRunner, "test-failure");
+      }
+    }
+    await (originalOnAfterRunTest == null ? void 0 : originalOnAfterRunTest.call(testRunner, test));
+  };
+  return testRunner;
+}
+
+export { VitestSnapshotEnvironment as V, resolveTestRunner as r, setupChaiConfig as s };

package/dist/vendor-index.b271ebe4.js

@@ -0,0 +1,92 @@
+const DEFAULT_TIMEOUT = 6e4;
+function defaultSerialize(i) {
+  return i;
+}
+const defaultDeserialize = defaultSerialize;
+const { setTimeout } = globalThis;
+const random = Math.random.bind(Math);
+function createBirpc(functions, options) {
+  const {
+    post,
+    on,
+    eventNames = [],
+    serialize = defaultSerialize,
+    deserialize = defaultDeserialize,
+    resolver,
+    timeout = DEFAULT_TIMEOUT
+  } = options;
+  const rpcPromiseMap = /* @__PURE__ */ new Map();
+  let _promise;
+  const rpc = new Proxy({}, {
+    get(_, method) {
+      if (method === "$functions")
+        return functions;
+      const sendEvent = (...args) => {
+        post(serialize({ m: method, a: args, t: "q" }));
+      };
+      if (eventNames.includes(method)) {
+        sendEvent.asEvent = sendEvent;
+        return sendEvent;
+      }
+      const sendCall = async (...args) => {
+        await _promise;
+        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;
+    }
+  });
+  _promise = on(async (data, ...extra) => {
+    const msg = deserialize(data);
+    if (msg.t === "q") {
+      const { m: method, a: args } = msg;
+      let result, error;
+      const fn = resolver ? resolver(method, functions[method]) : functions[method];
+      if (!fn) {
+        error = new Error(`[birpc] function "${method}" not found`);
+      } else {
+        try {
+          result = await fn.apply(rpc, args);
+        } catch (e) {
+          error = e;
+        }
+      }
+      if (msg.i) {
+        if (error && options.onError)
+          options.onError(error, method, args);
+        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 (promise) {
+        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[random() * 64 | 0];
+  return id;
+}
+
+export { createBirpc as c };

package/dist/{vendor-index.2af39fbb.js → vendor-index.eff408fd.js}

@@ -1,6 +1,6 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
-import { e as bench, c as createExpect, d as globalExpect, s as setupChaiConfig, v as vi, f as vitest } from './vendor-vi.dd6706cb.js';
-import { i as isFirstRun, r as runOnce } from './vendor-run-once.1fa85ba7.js';
+import { e as bench, c as createExpect, d as globalExpect, v as vi, f as vitest } from './vendor-vi.271667ef.js';
+import { i as isFirstRun, r as runOnce } from './vendor-run-once.3e5ef7d7.js';
 import * as chai from 'chai';
 import { assert, should } from 'chai';
 
@@ -110,7 +110,6 @@ var index = /*#__PURE__*/Object.freeze({
   it: it,
   onTestFailed: onTestFailed,
   runOnce: runOnce,
-  setupChaiConfig: setupChaiConfig,
   should: should,
   suite: suite,
   test: test,