vitest 0.0.64 → 0.0.65

package/dist/chunk-3GMBTS5G.js

@@ -0,0 +1,19 @@
+import {
+  init_esm_shims
+} from "./chunk-RNHB4AXG.js";
+
+// node_modules/.pnpm/nanoid@3.1.30/node_modules/nanoid/non-secure/index.js
+init_esm_shims();
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+var nanoid = (size = 21) => {
+  let id = "";
+  let i = size;
+  while (i--) {
+    id += urlAlphabet[Math.random() * 64 | 0];
+  }
+  return id;
+};
+
+export {
+  nanoid
+};

package/dist/chunk-LRXUKIDM.js

@@ -0,0 +1,246 @@
+import {
+  nanoid
+} from "./chunk-3GMBTS5G.js";
+import {
+  defaultHookTimeout,
+  defaultTestTimeout,
+  init_esm_shims
+} from "./chunk-RNHB4AXG.js";
+
+// src/runtime/suite.ts
+init_esm_shims();
+
+// src/runtime/context.ts
+init_esm_shims();
+var context = {
+  tasks: [],
+  currentSuite: null
+};
+
+// src/runtime/map.ts
+init_esm_shims();
+var fnMap = new WeakMap();
+var hooksMap = new WeakMap();
+function setFn(key, fn) {
+  fnMap.set(key, fn);
+}
+function getFn(key) {
+  return fnMap.get(key);
+}
+function setHooks(key, hooks) {
+  hooksMap.set(key, hooks);
+}
+function getHooks(key) {
+  return hooksMap.get(key);
+}
+
+// src/runtime/suite.ts
+var suite = createSuite();
+var defaultSuite = suite("");
+function getCurrentSuite() {
+  return context.currentSuite || defaultSuite;
+}
+function createSuiteHooks() {
+  return {
+    beforeAll: [],
+    afterAll: [],
+    beforeEach: [],
+    afterEach: []
+  };
+}
+function createSuiteCollector(name, factory = () => {
+}, mode, suiteComputeMode) {
+  var _a;
+  const tasks = [];
+  const factoryQueue = [];
+  let suite2;
+  initSuite();
+  const test2 = createTestCollector((name2, fn, mode2, computeMode) => {
+    const test3 = {
+      id: nanoid(),
+      type: "test",
+      name: name2,
+      mode: mode2,
+      computeMode: computeMode ?? (suiteComputeMode ?? "serial"),
+      suite: void 0
+    };
+    setFn(test3, fn);
+    tasks.push(test3);
+  });
+  const collector = {
+    type: "collector",
+    name,
+    mode,
+    test: test2,
+    tasks,
+    collect,
+    clear,
+    on: addHook
+  };
+  function addHook(name2, ...fn) {
+    getHooks(suite2)[name2].push(...fn);
+  }
+  function initSuite() {
+    suite2 = {
+      id: nanoid(),
+      type: "suite",
+      computeMode: "serial",
+      name,
+      mode,
+      tasks: []
+    };
+    setHooks(suite2, createSuiteHooks());
+  }
+  function clear() {
+    tasks.length = 0;
+    factoryQueue.length = 0;
+    initSuite();
+  }
+  async function collect(file) {
+    factoryQueue.length = 0;
+    if (factory) {
+      const prev = context.currentSuite;
+      context.currentSuite = collector;
+      await factory(test2);
+      context.currentSuite = prev;
+    }
+    const allChildren = await Promise.all([...factoryQueue, ...tasks].map((i) => i.type === "collector" ? i.collect(file) : i));
+    suite2.file = file;
+    suite2.tasks = allChildren;
+    allChildren.forEach((task) => {
+      task.suite = suite2;
+      if (file)
+        task.file = file;
+    });
+    return suite2;
+  }
+  (_a = context.currentSuite) == null ? void 0 : _a.tasks.push(collector);
+  return collector;
+}
+function createTestCollector(collectTest) {
+  function test2(name, fn, timeout) {
+    collectTest(name, withTimeout(fn, timeout), "run");
+  }
+  test2.concurrent = concurrent;
+  test2.skip = skip;
+  test2.only = only;
+  test2.todo = todo;
+  function concurrent(name, fn, timeout) {
+    collectTest(name, withTimeout(fn, timeout), "run", "concurrent");
+  }
+  concurrent.skip = (name, fn, timeout) => collectTest(name, withTimeout(fn, timeout), "skip", "concurrent");
+  concurrent.only = (name, fn, timeout) => collectTest(name, withTimeout(fn, timeout), "only", "concurrent");
+  concurrent.todo = todo;
+  function skip(name, fn, timeout) {
+    collectTest(name, withTimeout(fn, timeout), "skip");
+  }
+  skip.concurrent = concurrent.skip;
+  function only(name, fn, timeout) {
+    collectTest(name, withTimeout(fn, timeout), "only");
+  }
+  only.concurrent = concurrent.only;
+  function todo(name) {
+    collectTest(name, () => {
+    }, "todo");
+  }
+  todo.concurrent = todo;
+  return test2;
+}
+var test = function() {
+  function test2(name, fn, timeout) {
+    return getCurrentSuite().test(name, fn, timeout);
+  }
+  function concurrent(name, fn, timeout) {
+    return getCurrentSuite().test.concurrent(name, fn, timeout);
+  }
+  concurrent.skip = (name, fn, timeout) => getCurrentSuite().test.concurrent.skip(name, fn, timeout);
+  concurrent.only = (name, fn, timeout) => getCurrentSuite().test.concurrent.only(name, fn, timeout);
+  concurrent.todo = (name) => getCurrentSuite().test.concurrent.todo(name);
+  function skip(name, fn, timeout) {
+    return getCurrentSuite().test.skip(name, fn, timeout);
+  }
+  skip.concurrent = (name, fn, timeout) => getCurrentSuite().test.skip.concurrent(name, fn, timeout);
+  function only(name, fn, timeout) {
+    return getCurrentSuite().test.only(name, fn, timeout);
+  }
+  only.concurrent = (name, fn, timeout) => getCurrentSuite().test.only.concurrent(name, fn, timeout);
+  function todo(name) {
+    return getCurrentSuite().test.todo(name);
+  }
+  todo.concurrent = (name) => getCurrentSuite().test.todo.concurrent(name);
+  test2.concurrent = concurrent;
+  test2.skip = skip;
+  test2.only = only;
+  test2.todo = todo;
+  return test2;
+}();
+function createSuite() {
+  function suite2(suiteName, factory) {
+    return createSuiteCollector(suiteName, factory, "run");
+  }
+  function concurrent(suiteName, factory) {
+    return createSuiteCollector(suiteName, factory, "run", "concurrent");
+  }
+  concurrent.skip = (suiteName, factory) => createSuiteCollector(suiteName, factory, "skip", "concurrent");
+  concurrent.only = (suiteName, factory) => createSuiteCollector(suiteName, factory, "only", "concurrent");
+  concurrent.todo = (suiteName) => createSuiteCollector(suiteName, void 0, "todo");
+  function skip(suiteName, factory) {
+    return createSuiteCollector(suiteName, factory, "skip");
+  }
+  skip.concurrent = concurrent.skip;
+  function only(suiteName, factory) {
+    return createSuiteCollector(suiteName, factory, "only");
+  }
+  only.concurrent = concurrent.only;
+  function todo(suiteName) {
+    return createSuiteCollector(suiteName, void 0, "todo");
+  }
+  todo.concurrent = concurrent.todo;
+  suite2.concurrent = concurrent;
+  suite2.skip = skip;
+  suite2.only = only;
+  suite2.todo = todo;
+  return suite2;
+}
+var describe = suite;
+var it = test;
+var beforeAll = (fn, timeout = defaultHookTimeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout));
+var afterAll = (fn, timeout = defaultHookTimeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout));
+var beforeEach = (fn, timeout = defaultHookTimeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout));
+var afterEach = (fn, timeout = defaultHookTimeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout));
+function clearContext() {
+  context.tasks.length = 0;
+  defaultSuite.clear();
+  context.currentSuite = defaultSuite;
+}
+function withTimeout(fn, timeout = defaultTestTimeout) {
+  if (timeout <= 0 || timeout === Infinity)
+    return fn;
+  return (...args) => {
+    return Promise.race([fn(...args), new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        clearTimeout(timer);
+        reject(new Error(`Test timed out in ${timeout}ms.`));
+      }, timeout);
+      timer.unref();
+    })]);
+  };
+}
+
+export {
+  context,
+  getFn,
+  setHooks,
+  getHooks,
+  suite,
+  defaultSuite,
+  createSuiteHooks,
+  test,
+  describe,
+  it,
+  beforeAll,
+  afterAll,
+  beforeEach,
+  afterEach,
+  clearContext
+};

package/dist/chunk-NK2VTQLQ.js

@@ -0,0 +1,81 @@
+import {
+  init_esm_shims
+} from "./chunk-RNHB4AXG.js";
+
+// src/utils.ts
+init_esm_shims();
+function toArray(array) {
+  array = array || [];
+  if (Array.isArray(array))
+    return array;
+  return [array];
+}
+function notNullish(v) {
+  return v != null;
+}
+function slash(str) {
+  return str.replace(/\\/g, "/");
+}
+function partitionSuiteChildren(suite) {
+  let tasksGroup = [];
+  const tasksGroups = [];
+  for (const c of suite.tasks) {
+    if (tasksGroup.length === 0 || c.computeMode === tasksGroup[0].computeMode) {
+      tasksGroup.push(c);
+    } else {
+      tasksGroups.push(tasksGroup);
+      tasksGroup = [c];
+    }
+  }
+  if (tasksGroup.length > 0)
+    tasksGroups.push(tasksGroup);
+  return tasksGroups;
+}
+function interpretOnlyMode(items) {
+  if (items.some((i) => i.mode === "only")) {
+    items.forEach((i) => {
+      if (i.mode === "run")
+        i.mode = "skip";
+      else if (i.mode === "only")
+        i.mode = "run";
+    });
+  }
+}
+function getTests(suite) {
+  return toArray(suite).flatMap((s) => s.tasks.flatMap((c) => c.type === "test" ? [c] : getTests(c)));
+}
+function getSuites(suite) {
+  return toArray(suite).flatMap((s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []);
+}
+function hasTests(suite) {
+  return toArray(suite).some((s) => s.tasks.some((c) => c.type === "test" || hasTests(c)));
+}
+function hasFailed(suite) {
+  return toArray(suite).some((s) => {
+    var _a;
+    return ((_a = s.result) == null ? void 0 : _a.state) === "fail" || s.type === "suite" && hasFailed(s.tasks);
+  });
+}
+function getNames(task) {
+  const names = [task.name];
+  let current = task;
+  while ((current == null ? void 0 : current.suite) || (current == null ? void 0 : current.file)) {
+    current = current.suite || current.file;
+    if (current == null ? void 0 : current.name)
+      names.unshift(current.name);
+  }
+  return names;
+}
+
+export {
+  toArray,
+  notNullish,
+  slash,
+  partitionSuiteChildren,
+  interpretOnlyMode,
+  getTests,
+  getSuites,
+  hasTests,
+  hasFailed,
+  getNames
+};

package/dist/chunk-RNHB4AXG.js

@@ -0,0 +1,128 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module, desc) => {
+  if (module && typeof module === "object" || typeof module === "function") {
+    for (let key of __getOwnPropNames(module))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module) => {
+  return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateWrapper = (obj, member, setter, getter) => {
+  return {
+    set _(value) {
+      __privateSet(obj, member, value, setter);
+    },
+    get _() {
+      return __privateGet(obj, member, getter);
+    }
+  };
+};
+
+// node_modules/.pnpm/tsup@5.11.1_typescript@4.5.3/node_modules/tsup/assets/esm_shims.js
+import { fileURLToPath } from "url";
+import path from "path";
+var init_esm_shims = __esm({
+  "node_modules/.pnpm/tsup@5.11.1_typescript@4.5.3/node_modules/tsup/assets/esm_shims.js"() {
+  }
+});
+
+// src/constants.ts
+init_esm_shims();
+import { resolve } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var distDir = resolve(fileURLToPath2(import.meta.url), "../../dist");
+var defaultTestTimeout = 5e3;
+var defaultHookTimeout = 5e3;
+var defaultIncludes = ["**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"];
+var defaultExcludes = ["**/node_modules/**", "**/dist/**"];
+var globalApis = [
+  "suite",
+  "test",
+  "describe",
+  "it",
+  "chai",
+  "expect",
+  "assert",
+  "sinon",
+  "spy",
+  "mock",
+  "stub",
+  "beforeAll",
+  "afterAll",
+  "beforeEach",
+  "afterEach"
+];
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __commonJS,
+  __export,
+  __toModule,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateWrapper,
+  init_esm_shims,
+  distDir,
+  defaultTestTimeout,
+  defaultHookTimeout,
+  defaultIncludes,
+  defaultExcludes,
+  globalApis
+};

package/dist/chunk-SF66BJ42.js

@@ -0,0 +1,78 @@
+import {
+  init_esm_shims
+} from "./chunk-RNHB4AXG.js";
+
+// src/integrations/snapshot/port/jest-test-result-helper.ts
+init_esm_shims();
+var emptySummary = (options) => {
+  const summary = {
+    added: 0,
+    failure: false,
+    filesAdded: 0,
+    filesRemoved: 0,
+    filesRemovedList: [],
+    filesUnmatched: 0,
+    filesUpdated: 0,
+    matched: 0,
+    total: 0,
+    unchecked: 0,
+    uncheckedKeysByFile: [],
+    unmatched: 0,
+    updated: 0,
+    didUpdate: options.updateSnapshot === "all"
+  };
+  return summary;
+};
+var packSnapshotState = (filepath, state) => {
+  const snapshot = {
+    filepath,
+    added: 0,
+    fileDeleted: false,
+    matched: 0,
+    unchecked: 0,
+    uncheckedKeys: [],
+    unmatched: 0,
+    updated: 0
+  };
+  const uncheckedCount = state.getUncheckedCount();
+  const uncheckedKeys = state.getUncheckedKeys();
+  if (uncheckedCount)
+    state.removeUncheckedKeys();
+  const status = state.save();
+  snapshot.fileDeleted = status.deleted;
+  snapshot.added = state.added;
+  snapshot.matched = state.matched;
+  snapshot.unmatched = state.unmatched;
+  snapshot.updated = state.updated;
+  snapshot.unchecked = !status.deleted ? uncheckedCount : 0;
+  snapshot.uncheckedKeys = Array.from(uncheckedKeys);
+  return snapshot;
+};
+var addSnapshotResult = (summary, result) => {
+  if (result.added)
+    summary.filesAdded++;
+  if (result.fileDeleted)
+    summary.filesRemoved++;
+  if (result.unmatched)
+    summary.filesUnmatched++;
+  if (result.updated)
+    summary.filesUpdated++;
+  summary.added += result.added;
+  summary.matched += result.matched;
+  summary.unchecked += result.unchecked;
+  if (result.uncheckedKeys && result.uncheckedKeys.length > 0) {
+    summary.uncheckedKeysByFile.push({
+      filePath: result.filepath,
+      keys: result.uncheckedKeys
+    });
+  }
+  summary.unmatched += result.unmatched;
+  summary.updated += result.updated;
+  summary.total += result.added + result.matched + result.unmatched + result.updated;
+};
+
+export {
+  emptySummary,
+  packSnapshotState,
+  addSnapshotResult
+};

package/dist/chunk-VAUJEKEW.js

@@ -0,0 +1,86 @@
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  clearContext,
+  createSuiteHooks,
+  defaultSuite,
+  describe,
+  it,
+  suite,
+  test
+} from "./chunk-LRXUKIDM.js";
+import {
+  __export,
+  init_esm_shims
+} from "./chunk-RNHB4AXG.js";
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  afterAll: () => afterAll,
+  afterEach: () => afterEach,
+  assert: () => assert,
+  beforeAll: () => beforeAll,
+  beforeEach: () => beforeEach,
+  chai: () => chai,
+  clearContext: () => clearContext,
+  createSuiteHooks: () => createSuiteHooks,
+  defaultSuite: () => defaultSuite,
+  describe: () => describe,
+  expect: () => expect,
+  it: () => it,
+  mock: () => mock,
+  should: () => should,
+  sinon: () => sinon,
+  spy: () => spy,
+  stub: () => stub,
+  suite: () => suite,
+  test: () => test
+});
+init_esm_shims();
+
+// src/types/index.ts
+init_esm_shims();
+
+// src/types/options.ts
+init_esm_shims();
+
+// src/types/tasks.ts
+init_esm_shims();
+
+// src/types/reporter.ts
+init_esm_shims();
+
+// src/types/snapshot.ts
+init_esm_shims();
+
+// src/types/worker.ts
+init_esm_shims();
+
+// src/types/general.ts
+init_esm_shims();
+
+// src/integrations/chai/index.ts
+init_esm_shims();
+import chai from "chai";
+import { assert, should, expect } from "chai";
+
+// src/integrations/sinon.ts
+init_esm_shims();
+import sinon from "sinon";
+var { mock, spy, stub } = sinon;
+sinon.fn = sinon.spy;
+
+export {
+  chai,
+  assert,
+  should,
+  expect,
+  sinon,
+  mock,
+  spy,
+  stub,
+  src_exports
+};

package/dist/global-OS2VOPCA.js

@@ -0,0 +1,20 @@
+import {
+  src_exports
+} from "./chunk-VAUJEKEW.js";
+import "./chunk-LRXUKIDM.js";
+import "./chunk-3GMBTS5G.js";
+import {
+  globalApis,
+  init_esm_shims
+} from "./chunk-RNHB4AXG.js";
+
+// src/integrations/global.ts
+init_esm_shims();
+function registerApiGlobally() {
+  globalApis.forEach((api) => {
+    globalThis[api] = src_exports[api];
+  });
+}
+export {
+  registerApiGlobally
+};

package/dist/index.d.ts

@@ -1,12 +1,10 @@
-import { R as ResolvedConfig, F as File, T as TaskResultPack, S as SnapshotResult, a as TestFactory, b as SuiteCollector, c as TestFunction, d as SuiteHooks, U as UserOptions } from './options-654578ef';
-export { C as CliOptions, g as ComputeMode, F as File, G as GlobalContext, H as HookListener, n as Reporter, R as ResolvedConfig, e as RunMode, o as SnapshotData, r as SnapshotMatchOptions, S as SnapshotResult, q as SnapshotStateOptions, t as SnapshotSummary, p as SnapshotUpdateState, j as Suite, b as SuiteCollector, d as SuiteHooks, l as Task, h as TaskBase, i as TaskResult, T as TaskResultPack, f as TaskState, k as Test, m as TestCollector, a as TestFactory, c as TestFunction, s as UncheckedSnapshot, U as UserOptions } from './options-654578ef';
+import { R as ResolvedConfig, F as File, T as TaskResultPack, S as SnapshotResult, a as TestFactory, b as SuiteCollector, c as TestFunction, d as SuiteHooks, U as UserOptions } from './options-652352ad';
+export { u as Arrayable, A as Awaitable, C as CliOptions, g as ComputeMode, v as Environment, E as EnvironmentReturn, F as File, G as GlobalContext, H as HookListener, M as ModuleCache, N as Nullable, n as Reporter, R as ResolvedConfig, e as RunMode, o as SnapshotData, r as SnapshotMatchOptions, S as SnapshotResult, q as SnapshotStateOptions, t as SnapshotSummary, p as SnapshotUpdateState, j as Suite, b as SuiteCollector, d as SuiteHooks, l as Task, h as TaskBase, i as TaskResult, T as TaskResultPack, f as TaskState, k as Test, m as TestCollector, a as TestFactory, c as TestFunction, s as UncheckedSnapshot, U as UserOptions, V as VitestContext } from './options-652352ad';
 import { MessagePort } from 'worker_threads';
 import { TransformResult } from 'vite';
-export { a as Environment, E as EnvironmentReturn, M as ModuleCache, V as VitestContext } from './general-39d52683';
 export { assert, default as chai, expect, should } from 'chai';
 import sinon from 'sinon';
 export { default as sinon } from 'sinon';
-import '@antfu/utils';
 import 'pretty-format';
 
 interface WorkerContext {