vitest 0.0.65 → 0.0.69

package/dist/global-e40b54d6.js

@@ -0,0 +1,16 @@
+import { g as globalApis } from './constants-d4c70610.js';
+import { i as index } from './index-e37648e9.js';
+import 'path';
+import 'url';
+import './suite-819c135e.js';
+import './index-6427e0f2.js';
+import 'chai';
+import 'sinon';
+
+function registerApiGlobally() {
+  globalApis.forEach((api) => {
+    globalThis[api] = index[api];
+  });
+}
+
+export { registerApiGlobally };

package/dist/index-6427e0f2.js

@@ -0,0 +1,12 @@
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+let nanoid = (size = 21) => {
+  let id = '';
+  let i = size;
+  while (i--) {
+    id += urlAlphabet[(Math.random() * 64) | 0];
+  }
+  return id
+};
+
+export { nanoid as n };

package/dist/index-e37648e9.js

@@ -0,0 +1,31 @@
+import { s as suite, d as defaultSuite, c as createSuiteHooks, t as test, a as describe, i as it, b as beforeAll, e as afterAll, f as beforeEach, g as afterEach, h as clearContext } from './suite-819c135e.js';
+import chai, { assert, should, expect } from 'chai';
+import sinon from 'sinon';
+
+const { mock, spy, stub } = sinon;
+sinon.fn = sinon.spy;
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  suite: suite,
+  defaultSuite: defaultSuite,
+  createSuiteHooks: createSuiteHooks,
+  test: test,
+  describe: describe,
+  it: it,
+  beforeAll: beforeAll,
+  afterAll: afterAll,
+  beforeEach: beforeEach,
+  afterEach: afterEach,
+  clearContext: clearContext,
+  assert: assert,
+  should: should,
+  expect: expect,
+  chai: chai,
+  sinon: sinon,
+  mock: mock,
+  spy: spy,
+  stub: stub
+});
+
+export { stub as a, index as i, mock as m, spy as s };

package/dist/index.d.ts

@@ -1,11 +1,299 @@
-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 { TransformResult, ViteDevServer } from 'vite';
+import { OptionsReceived } from 'pretty-format';
 import { MessagePort } from 'worker_threads';
-import { TransformResult } from 'vite';
 export { assert, default as chai, expect, should } from 'chai';
 import sinon from 'sinon';
 export { default as sinon } from 'sinon';
-import 'pretty-format';
+
+declare class StateManager {
+    filesMap: Record<string, File>;
+    idMap: Record<string, Task>;
+    taskFileMap: WeakMap<Task, File>;
+    getFiles(keys?: string[]): File[];
+    collectFiles(files: File[]): void;
+    updateId(task: Task): void;
+    updateTasks(packs: TaskResultPack[]): void;
+}
+
+declare class SnapshotManager {
+    config: ResolvedConfig;
+    summary: SnapshotSummary;
+    constructor(config: ResolvedConfig);
+    clear(): void;
+    add(result: SnapshotResult): void;
+}
+
+declare type Awaitable<T> = T | PromiseLike<T>;
+declare type Nullable<T> = T | null | undefined;
+declare type Arrayable<T> = T | Array<T>;
+interface ModuleCache {
+    promise?: Promise<any>;
+    exports?: any;
+    transformResult?: TransformResult;
+}
+interface EnvironmentReturn {
+    teardown: (global: any) => Awaitable<void>;
+}
+interface Environment {
+    name: string;
+    setup(global: any): Awaitable<EnvironmentReturn>;
+}
+interface VitestContext {
+    config: ResolvedConfig;
+    server: ViteDevServer;
+    state: StateManager;
+    snapshot: SnapshotManager;
+    reporter: Reporter;
+}
+
+declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
+declare type TaskState = RunMode | 'pass' | 'fail';
+declare type ComputeMode = 'serial' | 'concurrent';
+interface TaskBase {
+    id: string;
+    name: string;
+    mode: RunMode;
+    computeMode: ComputeMode;
+    suite?: Suite;
+    file?: File;
+    result?: TaskResult;
+}
+interface TaskResult {
+    state: TaskState;
+    start: number;
+    end?: number;
+    error?: unknown;
+}
+declare type TaskResultPack = [id: string, result: TaskResult | undefined];
+interface Suite extends TaskBase {
+    type: 'suite';
+    tasks: Task[];
+}
+interface File extends Suite {
+    filepath: string;
+}
+interface Test extends TaskBase {
+    type: 'test';
+    suite: Suite;
+    result?: TaskResult;
+}
+declare type Task = Test | Suite | File;
+declare type TestFunction = () => Awaitable<void>;
+declare type TestCollectorFn = (name: string, fn: TestFunction, timeout?: number) => void;
+interface ConcurrentCollector {
+    (name: string, fn: TestFunction, timeout?: number): void;
+    only: TestCollectorFn;
+    skip: TestCollectorFn;
+    todo: (name: string) => void;
+}
+interface OnlyCollector {
+    (name: string, fn: TestFunction, timeout?: number): void;
+    concurrent: TestCollectorFn;
+}
+interface SkipCollector {
+    (name: string, fn: TestFunction, timeout?: number): void;
+    concurrent: TestCollectorFn;
+}
+interface TodoCollector {
+    (name: string): void;
+    concurrent: (name: string) => void;
+}
+interface TestCollector {
+    (name: string, fn: TestFunction, timeout?: number): void;
+    concurrent: ConcurrentCollector;
+    only: OnlyCollector;
+    skip: SkipCollector;
+    todo: TodoCollector;
+}
+declare type HookListener<T extends any[]> = (...args: T) => Awaitable<void>;
+interface SuiteHooks {
+    beforeAll: HookListener<[Suite]>[];
+    afterAll: HookListener<[Suite]>[];
+    beforeEach: HookListener<[Test, Suite]>[];
+    afterEach: HookListener<[Test, Suite]>[];
+}
+interface SuiteCollector {
+    readonly name: string;
+    readonly mode: RunMode;
+    type: 'collector';
+    test: TestCollector;
+    tasks: (Suite | Test | SuiteCollector)[];
+    collect: (file?: File) => Promise<Suite>;
+    clear: () => void;
+    on: <T extends keyof SuiteHooks>(name: T, ...fn: SuiteHooks[T]) => void;
+}
+declare type TestFactory = (test: (name: string, fn: TestFunction) => void) => Awaitable<void>;
+interface GlobalContext {
+    tasks: (SuiteCollector | Test)[];
+    currentSuite: SuiteCollector | null;
+}
+
+interface Reporter {
+    onStart?: (files?: string[]) => Awaitable<void>;
+    onFinished?: (files?: File[]) => Awaitable<void>;
+    onTaskUpdate?: (pack: TaskResultPack) => Awaitable<void>;
+    onWatcherStart?: () => Awaitable<void>;
+    onWatcherRerun?: (files: string[], trigger: string) => Awaitable<void>;
+}
+
+declare type SnapshotData = Record<string, string>;
+declare type SnapshotUpdateState = 'all' | 'new' | 'none';
+declare type SnapshotStateOptions = {
+    updateSnapshot: SnapshotUpdateState;
+    expand?: boolean;
+    snapshotFormat?: OptionsReceived;
+};
+declare type SnapshotMatchOptions = {
+    testName: string;
+    received: unknown;
+    key?: string;
+    inlineSnapshot?: string;
+    isInline: boolean;
+    error?: Error;
+};
+interface SnapshotResult {
+    filepath: string;
+    added: number;
+    fileDeleted: boolean;
+    matched: number;
+    unchecked: number;
+    uncheckedKeys: Array<string>;
+    unmatched: number;
+    updated: number;
+}
+interface UncheckedSnapshot {
+    filePath: string;
+    keys: Array<string>;
+}
+interface SnapshotSummary {
+    added: number;
+    didUpdate: boolean;
+    failure: boolean;
+    filesAdded: number;
+    filesRemoved: number;
+    filesRemovedList: Array<string>;
+    filesUnmatched: number;
+    filesUpdated: number;
+    matched: number;
+    total: number;
+    unchecked: number;
+    uncheckedKeysByFile: Array<UncheckedSnapshot>;
+    unmatched: number;
+    updated: number;
+}
+
+interface UserOptions {
+    /**
+     * Include globs for test files
+     *
+     * @default ['**\/*.test.ts']
+     */
+    includes?: string[];
+    /**
+     * Exclude globs for test files
+     * @default ['**\/node_modules\/**']
+     */
+    excludes?: string[];
+    /**
+     * Handling for dependencies inlining or externalizing
+     */
+    deps?: {
+        /**
+         * Externalize means that Vite will bypass the package to native Node.
+         *
+         * Externaled dependencies will not be applied Vite's transformers and resolvers.
+         * And does not support HMR on reload.
+         *
+         * Typically, packages under `node_modules` are externalized.
+         */
+        external?: (string | RegExp)[];
+        /**
+         * Vite will process inlined modules.
+         *
+         * This could be helpful to handle packages that ship `.js` in ESM format (that Node can't handle).
+         */
+        inline?: (string | RegExp)[];
+    };
+    /**
+     * Register apis globally
+     *
+     * @default false
+     */
+    global?: boolean;
+    /**
+     * Running environment
+     *
+     * Supports 'node', 'jsdom', 'happy-dom'
+     *
+     * @default 'node'
+     */
+    environment?: 'node' | 'jsdom' | 'happy-dom';
+    /**
+     * Update snapshot files
+     *
+     * @default false
+     */
+    update?: boolean;
+    /**
+     * Watch mode
+     *
+     * @default false
+     */
+    watch?: boolean;
+    /**
+     * Project root
+     */
+    root?: string;
+    /**
+     * Custom reporter for output
+     */
+    reporter?: Reporter;
+    /**
+     * Enable multi-threading
+     *
+     * @default true
+     */
+    threads?: boolean;
+    /**
+     * Maximum number of threads
+     *
+     * @default available CPUs
+     */
+    maxThreads?: number;
+    /**
+     * Minimum number of threads
+     *
+     * @default available CPUs
+     */
+    minThreads?: number;
+    interpretDefault?: boolean;
+    testTimeout?: number;
+    hookTimeout?: number;
+}
+interface CliOptions extends UserOptions {
+    /**
+     * Filters by name
+     */
+    cliFilters?: string[];
+    /**
+     * Path to the config file.
+     *
+     * Default resolving to one of:
+     * - `vitest.config.js`
+     * - `vitest.config.ts`
+     * - `vite.config.js`
+     * - `vite.config.ts`
+     */
+    config?: string | undefined;
+    dom?: boolean;
+}
+interface ResolvedConfig extends Omit<Required<CliOptions>, 'config' | 'filters'> {
+    config?: string;
+    filters?: string[];
+    depsInline: (string | RegExp)[];
+    depsExternal: (string | RegExp)[];
+    snapshotOptions: SnapshotStateOptions;
+}
 
 interface WorkerContext {
     port: MessagePort;
@@ -122,11 +410,22 @@ declare const it: {
         concurrent(name: string): void;
     };
 };
-declare const beforeAll: (fn: SuiteHooks['beforeAll'][0], timeout?: number) => void;
-declare const afterAll: (fn: SuiteHooks['afterAll'][0], timeout?: number) => void;
-declare const beforeEach: (fn: SuiteHooks['beforeEach'][0], timeout?: number) => void;
-declare const afterEach: (fn: SuiteHooks['afterEach'][0], timeout?: number) => void;
+declare const beforeAll: (fn: SuiteHooks['beforeAll'][0], timeout?: number | undefined) => void;
+declare const afterAll: (fn: SuiteHooks['afterAll'][0], timeout?: number | undefined) => void;
+declare const beforeEach: (fn: SuiteHooks['beforeEach'][0], timeout?: number | undefined) => void;
+declare const afterEach: (fn: SuiteHooks['afterEach'][0], timeout?: number | undefined) => void;
 declare function clearContext(): void;
+declare global {
+    namespace NodeJS {
+        interface Process {
+            __vitest_worker__: {
+                config: ResolvedConfig;
+                rpc: RpcCall;
+                send: RpcSend;
+            };
+        }
+    }
+}
 
 declare const mock: sinon.SinonMockStatic;
 declare const spy: sinon.SinonSpyStatic;
@@ -192,4 +491,4 @@ declare global {
     }
 }
 
-export { RpcCall, RpcMap, RpcPayload, RpcSend, WorkerContext, afterAll, afterEach, beforeAll, beforeEach, clearContext, createSuiteHooks, defaultSuite, describe, it, mock, spy, stub, suite, test };
+export { Arrayable, Awaitable, CliOptions, ComputeMode, Environment, EnvironmentReturn, File, GlobalContext, HookListener, ModuleCache, Nullable, Reporter, ResolvedConfig, RpcCall, RpcMap, RpcPayload, RpcSend, RunMode, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, Suite, SuiteCollector, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestCollector, TestFactory, TestFunction, UncheckedSnapshot, UserOptions, VitestContext, WorkerContext, afterAll, afterEach, beforeAll, beforeEach, clearContext, createSuiteHooks, defaultSuite, describe, it, mock, spy, stub, suite, test };

package/dist/index.js

@@ -1,46 +1,5 @@
-import {
-  assert,
-  chai,
-  expect,
-  mock,
-  should,
-  sinon,
-  spy,
-  stub
-} from "./chunk-VAUJEKEW.js";
-import {
-  afterAll,
-  afterEach,
-  beforeAll,
-  beforeEach,
-  clearContext,
-  createSuiteHooks,
-  defaultSuite,
-  describe,
-  it,
-  suite,
-  test
-} from "./chunk-LRXUKIDM.js";
-import "./chunk-3GMBTS5G.js";
-import "./chunk-RNHB4AXG.js";
-export {
-  afterAll,
-  afterEach,
-  assert,
-  beforeAll,
-  beforeEach,
-  chai,
-  clearContext,
-  createSuiteHooks,
-  defaultSuite,
-  describe,
-  expect,
-  it,
-  mock,
-  should,
-  sinon,
-  spy,
-  stub,
-  suite,
-  test
-};
+export { e as afterAll, g as afterEach, b as beforeAll, f as beforeEach, h as clearContext, c as createSuiteHooks, d as defaultSuite, a as describe, i as it, s as suite, t as test } from './suite-819c135e.js';
+export { assert, default as chai, expect, should } from 'chai';
+export { m as mock, s as spy, a as stub } from './index-e37648e9.js';
+export { default as sinon } from 'sinon';
+import './index-6427e0f2.js';

package/dist/{chunk-LRXUKIDM.js → suite-819c135e.js}

@@ -1,26 +1,12 @@
-import {
-  nanoid
-} from "./chunk-3GMBTS5G.js";
-import {
-  defaultHookTimeout,
-  defaultTestTimeout,
-  init_esm_shims
-} from "./chunk-RNHB4AXG.js";
+import { n as nanoid } from './index-6427e0f2.js';
 
-// src/runtime/suite.ts
-init_esm_shims();
-
-// src/runtime/context.ts
-init_esm_shims();
-var context = {
+const context = {
   tasks: [],
   currentSuite: null
 };
 
-// src/runtime/map.ts
-init_esm_shims();
-var fnMap = new WeakMap();
-var hooksMap = new WeakMap();
+const fnMap = new WeakMap();
+const hooksMap = new WeakMap();
 function setFn(key, fn) {
   fnMap.set(key, fn);
 }
@@ -34,12 +20,19 @@ function getHooks(key) {
   return hooksMap.get(key);
 }
 
-// src/runtime/suite.ts
-var suite = createSuite();
-var defaultSuite = suite("");
+const suite = createSuite();
+const defaultSuite = suite("");
 function getCurrentSuite() {
   return context.currentSuite || defaultSuite;
 }
+const getDefaultTestTimeout = () => {
+  var _a, _b;
+  return ((_b = (_a = process.__vitest_worker__) == null ? void 0 : _a.config) == null ? void 0 : _b.testTimeout) ?? 5e3;
+};
+const getDefaultHookTimeout = () => {
+  var _a, _b;
+  return ((_b = (_a = process.__vitest_worker__) == null ? void 0 : _a.config) == null ? void 0 : _b.hookTimeout) ?? 5e3;
+};
 function createSuiteHooks() {
   return {
     beforeAll: [],
@@ -146,7 +139,7 @@ function createTestCollector(collectTest) {
   todo.concurrent = todo;
   return test2;
 }
-var test = function() {
+const test = function() {
   function test2(name, fn, timeout) {
     return getCurrentSuite().test(name, fn, timeout);
   }
@@ -202,18 +195,19 @@ function createSuite() {
   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));
+const describe = suite;
+const it = test;
+const beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
 function clearContext() {
   context.tasks.length = 0;
   defaultSuite.clear();
   context.currentSuite = defaultSuite;
 }
-function withTimeout(fn, timeout = defaultTestTimeout) {
+function withTimeout(fn, _timeout) {
+  const timeout = _timeout ?? getDefaultTestTimeout();
   if (timeout <= 0 || timeout === Infinity)
     return fn;
   return (...args) => {
@@ -227,20 +221,4 @@ function withTimeout(fn, timeout = defaultTestTimeout) {
   };
 }
 
-export {
-  context,
-  getFn,
-  setHooks,
-  getHooks,
-  suite,
-  defaultSuite,
-  createSuiteHooks,
-  test,
-  describe,
-  it,
-  beforeAll,
-  afterAll,
-  beforeEach,
-  afterEach,
-  clearContext
-};
+export { describe as a, beforeAll as b, createSuiteHooks as c, defaultSuite as d, afterAll as e, beforeEach as f, afterEach as g, clearContext as h, it as i, setHooks as j, context as k, getHooks as l, getFn as m, suite as s, test as t };

package/dist/{chunk-NK2VTQLQ.js → utils-9dcc4050.js}

@@ -1,9 +1,3 @@
-import {
-  init_esm_shims
-} from "./chunk-RNHB4AXG.js";
-
-// src/utils.ts
-init_esm_shims();
 function toArray(array) {
   array = array || [];
   if (Array.isArray(array))
@@ -67,15 +61,4 @@ function getNames(task) {
   return names;
 }
 
-export {
-  toArray,
-  notNullish,
-  slash,
-  partitionSuiteChildren,
-  interpretOnlyMode,
-  getTests,
-  getSuites,
-  hasTests,
-  hasFailed,
-  getNames
-};
+export { getTests as a, getSuites as b, hasTests as c, getNames as g, hasFailed as h, interpretOnlyMode as i, notNullish as n, partitionSuiteChildren as p, slash as s, toArray as t };