vitest 0.0.11 → 0.0.15

package/README.md

@@ -6,10 +6,11 @@ A blazing fast test runner powered by Vite.
 
 ## Features
 
-- [Vite](https://vitejs.dev/)'s config, transformers, resolvers, and plugins. Powered by [vite-node](https://github.com/antfu/vite-node)
+- [Vite](https://vitejs.dev/)'s config, transformers, resolvers, and plugins.
 - [Jest Snapshot](https://jestjs.io/docs/snapshot-testing)
 - [Chai](https://www.chaijs.com/) for assertions
 - [Sinon](https://sinonjs.org/) for mocking
+- [JSDOM](https://github.com/jsdom/jsdom) for DOM mocking
 - Async suite / test, top level await
 - ESM friendly
 - Out-of-box TypeScript support
@@ -20,11 +21,12 @@ import { it, describe, expect, assert } from 'vitest'
 
 describe('suite name', () => {
   it('foo', () => {
-    assert.equal(Math.sqrt(4), 2)
+    expect(1 + 1).toEqual(2)
+    expect(true).to.be.true
   })
 
   it('bar', () => {
-    expect(1 + 1).eq(2)
+    assert.equal(Math.sqrt(4), 2)
   })
 
   it('snapshot', () => {
@@ -37,6 +39,55 @@ describe('suite name', () => {
 $ npx vitest
 ```
 
+## Configuration
+
+`vitest` will read your root `vite.config.ts` when it present to match with the plugins and setup as your Vite app. If you want to it to have a different configuration for testing, you could either:
+
+- Create `vitest.config.ts`, which will have the higher priority
+- Pass `--config` option to CLI, e.g. `vitest --config ./path/to/vitest.config.ts`
+- Use `process.env.VITEST` to conditionally apply differnet configuration in `vite.config.ts`
+
+To configure `vitest` itself, add `test` property in your Vite config
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  test: {
+    // ...
+  }
+})
+```
+
+## Global APIs
+
+By default, `vitest` does not provide global APIs for explicitness. If you prefer to use the APIs globally like Jest, you can pass the `--global` option to CLI or add `global: true` in the config.
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  test: {
+    global: true
+  }
+})
+```
+
+To get TypeScript working with the global APIs, add `vitest/global` to the `types` filed in your `tsconfig.json`
+
+```json
+// tsconfig.json
+{
+  "compilerOptions": {
+    "types": [
+      "vitest/global"
+    ]
+  }
+}
+```
+
 ## Filtering
 
 ### Skipping suites and tasks
@@ -103,10 +154,12 @@ describe('suite', () => {
 - [x] Reporter & Better output
 - [x] Task filter
 - [x] Mock
+- [x] Global Mode & Types
 - [ ] Parallel Executing
 - [ ] CLI Help
 - [ ] JSDom
 - [ ] Watch
+- [ ] Source Map
 - [ ] Coverage
 
 ## Sponsors

package/bin/vitest.mjs

@@ -1,42 +1,4 @@
 #!/usr/bin/env node
 'use strict'
 
-import { fileURLToPath } from 'url'
-import { resolve, dirname } from 'path'
-import { run } from 'vite-node'
-import minimist from 'minimist'
-import { findUp } from 'find-up'
-
-const argv = minimist(process.argv.slice(2), {
-  alias: {
-    c: 'config',
-  },
-  string: ['root', 'config'],
-  boolean: ['dev'],
-})
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const root = resolve(argv.root || process.cwd())
-
-const configPath = argv.config ? resolve(root, argv.config) : await findUp(['vitest.config.ts', 'vitest.config.js', 'vitest.config.mjs', 'vite.config.ts', 'vite.config.js', 'vite.config.mjs'], { cwd: root })
-
-await run({
-  root,
-  files: [
-    resolve(__dirname, argv.dev ? '../src/cli.ts' : '../dist/cli.js'),
-  ],
-  config: configPath,
-  defaultConfig: {
-    optimizeDeps: {
-      exclude: [
-        'vitest',
-      ],
-    },
-  },
-  shouldExternalize(id) {
-    if (id.includes('/node_modules/vitest/'))
-      return false
-    else
-      return id.includes('/node_modules/')
-  },
-})
+import '../dist/entry.js'

package/dist/cli.js

@@ -6,9 +6,10 @@ const { log } = console;
 const argv = minimist(process.argv.slice(2), {
     alias: {
         u: 'update',
+        w: 'watch',
     },
     string: ['root', 'config'],
-    boolean: ['update', 'dev'],
+    boolean: ['update', 'dev', 'global', 'watch', 'jsdom'],
     unknown(name) {
         if (name[0] === '-') {
             console.error(c.red(`Unknown argument: ${name}`));
@@ -22,7 +23,7 @@ const argv = minimist(process.argv.slice(2), {
 const server = (_a = process === null || process === void 0 ? void 0 : process.__vite_node__) === null || _a === void 0 ? void 0 : _a.server;
 const viteConfig = (server === null || server === void 0 ? void 0 : server.config) || {};
 const testOptions = viteConfig.test || {};
-await run(Object.assign(Object.assign({}, testOptions), { updateSnapshot: argv.update, rootDir: argv.root || process.cwd() }));
+await run(Object.assign(Object.assign(Object.assign({}, argv), testOptions), { server, updateSnapshot: argv.update, rootDir: argv.root || process.cwd(), nameFilters: argv._ }));
 function help() {
     log('Help: finish help');
 }

package/dist/constants.d.ts

@@ -1,2 +1,3 @@
 export declare const defaultIncludes: string[];
 export declare const defaultExcludes: string[];
+export declare const globalApis: string[];

package/dist/constants.js

@@ -1,2 +1,22 @@
 export const defaultIncludes = ['**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'];
 export const defaultExcludes = ['**/node_modules/**', '**/dist/**'];
+export const globalApis = [
+    'suite',
+    'test',
+    'describe',
+    'it',
+    'expect',
+    'assert',
+    'spy',
+    'mock',
+    'stub',
+    'sinon',
+    'beforeAll',
+    'afterAll',
+    'beforeEach',
+    'afterEach',
+    'beforeFile',
+    'afterFile',
+    'beforeSuite',
+    'afterSuite',
+];

package/dist/entry.js

@@ -0,0 +1,38 @@
+import { fileURLToPath } from 'url';
+import { resolve, dirname } from 'path';
+import minimist from 'minimist';
+import { findUp } from 'find-up';
+import { run } from './node.js';
+process.env.VITEST = 'true';
+const argv = minimist(process.argv.slice(2), {
+    alias: {
+        c: 'config',
+    },
+    string: ['root', 'config'],
+    boolean: ['dev'],
+});
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = resolve(argv.root || process.cwd());
+const configPath = argv.config
+    ? resolve(root, argv.config)
+    : await findUp(['vitest.config.ts', 'vitest.config.js', 'vitest.config.mjs', 'vite.config.ts', 'vite.config.js', 'vite.config.mjs'], { cwd: root });
+await run({
+    root,
+    files: [
+        resolve(__dirname, argv.dev ? '../src/cli.ts' : './cli.js'),
+    ],
+    config: configPath,
+    defaultConfig: {
+        optimizeDeps: {
+            exclude: [
+                'vitest',
+            ],
+        },
+    },
+    shouldExternalize(id) {
+        if (id.includes('/node_modules/vitest/'))
+            return false;
+        else
+            return id.includes('/node_modules/');
+    },
+});

package/dist/global.d.ts

@@ -0,0 +1 @@
+export declare function registerApiGlobally(): void;

package/dist/global.js

@@ -0,0 +1,8 @@
+import { globalApis } from './constants';
+import * as index from './index';
+export function registerApiGlobally() {
+    globalApis.forEach((api) => {
+        // @ts-expect-error
+        globalThis[api] = index[api];
+    });
+}

package/dist/index.d.ts

@@ -1,8 +1,6 @@
-import sinon from 'sinon';
 export * from './types';
 export * from './suite';
 export * from './config';
-export * from './chai';
+export * from './integrations/chai';
+export * from './integrations/sinon';
 export { beforeAll, afterAll, beforeEach, afterEach, beforeFile, afterFile, beforeSuite, afterSuite } from './hooks';
-export { sinon };
-export declare const mock: sinon.SinonMockStatic, spy: sinon.SinonSpyStatic;

package/dist/index.js

@@ -1,8 +1,6 @@
-import sinon from 'sinon';
 export * from './types';
 export * from './suite';
 export * from './config';
-export * from './chai';
+export * from './integrations/chai';
+export * from './integrations/sinon';
 export { beforeAll, afterAll, beforeEach, afterEach, beforeFile, afterFile, beforeSuite, afterSuite } from './hooks';
-export { sinon };
-export const { mock, spy } = sinon;

package/dist/{chai.js → integrations/chai/index.d.ts}

@@ -1 +1,3 @@
+import chai from 'chai';
 export { assert, should, expect } from 'chai';
+export { chai };

package/dist/integrations/chai/index.js

@@ -0,0 +1,3 @@
+import chai from 'chai';
+export { assert, should, expect } from 'chai';
+export { chai };

package/dist/integrations/chai/jest-expect.d.ts

@@ -0,0 +1,21 @@
+import { ChaiPlugin } from './types';
+export declare function JestChaiExpect(): ChaiPlugin;
+declare global {
+    namespace Chai {
+        interface Assertion {
+            toEqual(expected: any): void;
+            toStrictEqual(expected: any): void;
+            toBe(expected: any): void;
+            toContain(item: any): void;
+            toBeTruthy(): void;
+            toBeFalsy(): void;
+            toBeNaN(): void;
+            toBeUndefined(): void;
+            toBeNull(): void;
+            toBeDefined(): void;
+        }
+        interface ExpectStatic {
+            addSnapshotSerializer: import('pretty-format').Plugin;
+        }
+    }
+}

package/dist/integrations/chai/jest-expect.js

@@ -0,0 +1,39 @@
+// Jest Expect Compact
+// TODO: add more https://jestjs.io/docs/expect
+export function JestChaiExpect() {
+    return (chai, utils) => {
+        const proto = chai.Assertion.prototype;
+        utils.addMethod(proto, 'toEqual', function (expected) {
+            return this.eql(expected);
+        });
+        utils.addMethod(proto, 'toStrictEqual', function (expected) {
+            return this.equal(expected);
+        });
+        utils.addMethod(proto, 'toBe', function (expected) {
+            return this.be(expected);
+        });
+        utils.addMethod(proto, 'toContain', function (item) {
+            return this.contain(item);
+        });
+        utils.addMethod(proto, 'toBeTruthy', function () {
+            const obj = utils.flag(this, 'object');
+            this.assert(Boolean(obj), 'expected #{this} to be truthy', 'expected #{this} to not be truthy', obj);
+        });
+        utils.addMethod(proto, 'toFalsy', function () {
+            const obj = utils.flag(this, 'object');
+            this.assert(!obj, 'expected #{this} to be falsy', 'expected #{this} to not be falsy', obj);
+        });
+        utils.addMethod(proto, 'toBeNaN', function () {
+            return this.be.NaN;
+        });
+        utils.addMethod(proto, 'toBeUndefined', function () {
+            return this.be.undefined;
+        });
+        utils.addMethod(proto, 'toBeNull', function () {
+            return this.be.null;
+        });
+        utils.addMethod(proto, 'toBeDefined', function () {
+            return this.not.be.undefined;
+        });
+    };
+}

package/dist/integrations/chai/setup.d.ts

@@ -0,0 +1,2 @@
+import { Config } from 'vitest';
+export declare function setupChai(config: Config): Promise<void>;

package/dist/integrations/chai/setup.js

@@ -0,0 +1,12 @@
+import chai from 'chai';
+import SinonChai from 'sinon-chai';
+import { JestChaiExpect } from './jest-expect';
+import { SnapshotPlugin } from './snapshot';
+export async function setupChai(config) {
+    chai.use(SinonChai);
+    chai.use(JestChaiExpect());
+    chai.use(await SnapshotPlugin({
+        rootDir: config.rootDir || process.cwd(),
+        update: config.updateSnapshot,
+    }));
+}

package/dist/{chai.d.ts → integrations/chai/snapshot/index.d.ts}

@@ -1,4 +1,9 @@
-export { assert, should, expect } from 'chai';
+import { ChaiPlugin } from '../types';
+export interface SnapshotOptions {
+    rootDir: string;
+    update?: boolean;
+}
+export declare function SnapshotPlugin(options: SnapshotOptions): Promise<ChaiPlugin>;
 declare global {
     namespace Chai {
         interface Assertion {

package/dist/{snapshot → integrations/chai/snapshot}/index.js

@@ -1,5 +1,5 @@
 import Snap from 'jest-snapshot';
-import { afterAll, beforeEach } from '../hooks';
+import { afterAll, beforeEach } from '../../../hooks';
 import { SnapshotManager } from './manager';
 const { addSerializer } = Snap;
 let _manager;

package/dist/{snapshot → integrations/chai/snapshot}/utils/jest-test-result-helper.js

@@ -4,6 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
+// @ts-ignore
 import Test from '@jest/test-result';
 const { makeEmptyAggregatedTestResult, } = Test;
 export const makeEmptySnapshotSummary = (options) => {

package/dist/integrations/chai/snapshot/utils/types.js

@@ -0,0 +1 @@
+export {};

package/dist/integrations/chai/types.d.ts

@@ -0,0 +1,3 @@
+import { use as chaiUse } from 'chai';
+export declare type FirstFunctionArgument<T> = T extends (arg: infer A) => unknown ? A : never;
+export declare type ChaiPlugin = FirstFunctionArgument<typeof chaiUse>;

package/dist/integrations/chai/types.js

@@ -0,0 +1 @@
+export {};

package/dist/integrations/jsdom.d.ts

@@ -0,0 +1,5 @@
+import { JSDOM } from 'jsdom';
+export declare function setupJSDOM(global: any): {
+    dom: JSDOM;
+    restore(): void;
+};

package/dist/integrations/jsdom.js

@@ -0,0 +1,20 @@
+import { JSDOM } from 'jsdom';
+export function setupJSDOM(global) {
+    const dom = new JSDOM('<!DOCTYPE html>', {
+        pretendToBeVisual: true,
+        runScripts: 'dangerously',
+        // TODO: options
+        url: 'http://localhost:3000',
+    });
+    const keys = Object.getOwnPropertyNames(dom.window)
+        .filter(k => !k.startsWith('_'))
+        .filter(k => !(k in global));
+    for (const key of keys)
+        global[key] = dom.window[key];
+    return {
+        dom,
+        restore() {
+            keys.forEach(key => delete global[key]);
+        },
+    };
+}

package/dist/integrations/sinon.d.ts

@@ -0,0 +1,3 @@
+import sinon from 'sinon';
+export { sinon };
+export declare const mock: sinon.SinonMockStatic, spy: sinon.SinonSpyStatic, stub: sinon.SinonStubStatic;

package/dist/integrations/sinon.js

@@ -0,0 +1,3 @@
+import sinon from 'sinon';
+export { sinon };
+export const { mock, spy, stub } = sinon;

package/dist/node.d.ts

@@ -0,0 +1,11 @@
+import { InlineConfig } from 'vite';
+export interface ViteNodeOptions {
+    silent?: boolean;
+    root: string;
+    files: string[];
+    _?: string[];
+    shouldExternalize?: (file: string) => boolean;
+    config?: string;
+    defaultConfig?: InlineConfig;
+}
+export declare function run(argv: ViteNodeOptions): Promise<void>;

package/dist/node.js

@@ -0,0 +1,126 @@
+import { builtinModules, createRequire } from 'module';
+import { pathToFileURL } from 'url';
+import { dirname, resolve, relative } from 'path';
+import vm from 'vm';
+import { createServer, mergeConfig } from 'vite';
+import c from 'picocolors';
+const { red, dim, yellow } = c;
+export async function run(argv) {
+    process.exitCode = 0;
+    const root = argv.root || process.cwd();
+    process.chdir(root);
+    const files = argv.files || argv._;
+    argv.shouldExternalize = argv.shouldExternalize || (id => id.includes('/node_modules/'));
+    const server = await createServer(mergeConfig(argv.defaultConfig || {}, {
+        logLevel: 'error',
+        clearScreen: false,
+        configFile: argv.config,
+        root,
+        resolve: {},
+    }));
+    await server.pluginContainer.buildStart({});
+    // @ts-expect-error
+    process.__vite_node__ = {
+        server,
+    };
+    try {
+        await execute(files, server, argv);
+    }
+    catch (e) {
+        process.exitCode = 1;
+        throw e;
+    }
+    finally {
+        await server.close();
+    }
+}
+function normalizeId(id) {
+    // Virtual modules start with `\0`
+    if (id && id.startsWith('/@id/__x00__'))
+        id = `\0${id.slice('/@id/__x00__'.length)}`;
+    if (id && id.startsWith('/@id/'))
+        id = id.slice('/@id/'.length);
+    return id;
+}
+function toFilePath(id, server) {
+    let absolute = id.startsWith('/@fs/')
+        ? id.slice(4)
+        : id.startsWith(dirname(server.config.root))
+            ? id
+            : slash(resolve(server.config.root, id.slice(1)));
+    if (absolute.startsWith('//'))
+        absolute = absolute.slice(1);
+    if (!absolute.startsWith('/'))
+        absolute = `/${absolute}`;
+    return absolute;
+}
+async function execute(files, server, options) {
+    const __pendingModules__ = new Map();
+    const result = [];
+    for (const file of files)
+        result.push(await cachedRequest(`/@fs/${slash(resolve(file))}`, []));
+    return result;
+    async function directRequest(rawId, callstack) {
+        if (builtinModules.includes(rawId))
+            return import(rawId);
+        callstack = [...callstack, rawId];
+        const request = async (dep) => {
+            if (callstack.includes(dep)) {
+                throw new Error(`${red('Circular dependency detected')}\nStack:\n${[...callstack, dep].reverse().map((i) => {
+                    const path = relative(server.config.root, toFilePath(normalizeId(i), server));
+                    return dim(' -> ') + (i === dep ? yellow(path) : path);
+                }).join('\n')}\n`);
+            }
+            return cachedRequest(dep, callstack);
+        };
+        const id = normalizeId(rawId);
+        const absolute = toFilePath(id, server);
+        if (options.shouldExternalize(absolute))
+            return import(absolute);
+        const result = await server.transformRequest(id, { ssr: true });
+        if (!result)
+            throw new Error(`failed to load ${id}`);
+        const url = pathToFileURL(absolute);
+        const exports = {};
+        const context = {
+            require: createRequire(url),
+            __filename: absolute,
+            __dirname: dirname(absolute),
+            __vite_ssr_import__: request,
+            __vite_ssr_dynamic_import__: request,
+            __vite_ssr_exports__: exports,
+            __vite_ssr_exportAll__: (obj) => exportAll(exports, obj),
+            __vite_ssr_import_meta__: { url },
+        };
+        const fn = vm.runInThisContext(`async (${Object.keys(context).join(',')}) => { ${result.code} }`, {
+            filename: absolute,
+            lineOffset: 0,
+        });
+        await fn(...Object.values(context));
+        return exports;
+    }
+    async function cachedRequest(id, callstack) {
+        if (__pendingModules__.has(id))
+            return __pendingModules__.get(id);
+        __pendingModules__.set(id, directRequest(id, callstack));
+        return await __pendingModules__.get(id);
+    }
+    function exportAll(exports, sourceModule) {
+        // eslint-disable-next-line no-restricted-syntax
+        for (const key in sourceModule) {
+            if (key !== 'default') {
+                try {
+                    Object.defineProperty(exports, key, {
+                        enumerable: true,
+                        configurable: true,
+                        get() { return sourceModule[key]; },
+                    });
+                }
+                catch (_err) { }
+            }
+        }
+    }
+}
+function slash(path) {
+    return path.replace(/\\/g, '/');
+}

package/dist/reporters/default.js

@@ -48,13 +48,13 @@ export class DefaultReporter {
         var _a;
         // @ts-expect-error
         (_a = task.__ora) === null || _a === void 0 ? void 0 : _a.stop();
-        if (task.status === 'pass') {
+        if (task.state === 'pass') {
             this.log(`${c.green(CHECK + task.name)}`);
         }
-        else if (task.status === 'skip') {
+        else if (task.state === 'skip') {
             this.log(c.dim(c.yellow(`${DOT + task.name} (skipped)`)));
         }
-        else if (task.status === 'todo') {
+        else if (task.state === 'todo') {
             this.log(c.dim(`${DOT + task.name} (todo)`));
         }
         else {
@@ -67,10 +67,11 @@ export class DefaultReporter {
         this.end = performance.now();
         const failedFiles = files.filter(i => i.error);
         const tasks = files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
-        const passed = tasks.filter(i => i.status === 'pass');
-        const failed = tasks.filter(i => i.status === 'fail');
-        const skipped = tasks.filter(i => i.status === 'skip');
-        const todo = tasks.filter(i => i.status === 'todo');
+        const runable = tasks.filter(i => i.state === 'pass' || i.state === 'fail');
+        const passed = tasks.filter(i => i.state === 'pass');
+        const failed = tasks.filter(i => i.state === 'fail');
+        const skipped = tasks.filter(i => i.state === 'skip');
+        const todo = tasks.filter(i => i.state === 'todo');
         this.indent = 0;
         if (failedFiles.length) {
             this.error(c.bold(`\nFailed to parse ${failedFiles.length} files:`));
@@ -89,9 +90,9 @@ export class DefaultReporter {
                 this.log();
             });
         }
-        this.log(c.green(`Passed   ${passed.length} / ${tasks.length}`));
+        this.log(c.green(`Passed   ${passed.length} / ${runable.length}`));
         if (failed.length)
-            this.log(c.red(`Failed   ${failed.length} / ${tasks.length}`));
+            this.log(c.red(`Failed   ${failed.length} / ${runable.length}`));
         if (skipped.length)
             this.log(c.yellow(`Skipped  ${skipped.length}`));
         if (todo.length)

package/dist/run.d.ts

@@ -1,5 +1,5 @@
-import { File, Options, Task, RunnerContext } from './types';
+import { File, Config, Task, RunnerContext } from './types';
 export declare function runTask(task: Task, ctx: RunnerContext): Promise<void>;
-export declare function collectFiles(files: string[]): Promise<File[]>;
+export declare function collectFiles(paths: string[]): Promise<File[]>;
 export declare function runFile(file: File, ctx: RunnerContext): Promise<void>;
-export declare function run(options?: Options): Promise<void>;
+export declare function run(config: Config): Promise<void>;

package/dist/run.js

@@ -1,39 +1,31 @@
-import chai from 'chai';
 import fg from 'fast-glob';
-import SinonChai from 'sinon-chai';
+import { setupChai } from './integrations/chai/setup';
 import { clearContext, defaultSuite } from './suite';
 import { context } from './context';
 import { afterEachHook, afterFileHook, afterAllHook, afterSuiteHook, beforeEachHook, beforeFileHook, beforeAllHook, beforeSuiteHook } from './hooks';
-import { SnapshotPlugin } from './snapshot';
 import { DefaultReporter } from './reporters/default';
 import { defaultIncludes, defaultExcludes } from './constants';
 export async function runTask(task, ctx) {
     var _a, _b;
     const { reporter } = ctx;
     await ((_a = reporter.onTaskBegin) === null || _a === void 0 ? void 0 : _a.call(reporter, task, ctx));
-    await beforeEachHook.fire(task);
-    if (task.suite.mode === 'skip' || task.mode === 'skip') {
-        task.status = 'skip';
-    }
-    else if (task.suite.mode === 'todo' || task.mode === 'todo') {
-        task.status = 'todo';
-    }
-    else {
+    if (task.mode === 'run') {
+        await beforeEachHook.fire(task);
         try {
             await task.fn();
-            task.status = 'pass';
+            task.state = 'pass';
         }
         catch (e) {
-            task.status = 'fail';
+            task.state = 'fail';
             task.error = e;
         }
+        await afterEachHook.fire(task);
     }
-    await afterEachHook.fire(task);
     await ((_b = reporter.onTaskEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, task, ctx));
 }
-export async function collectFiles(files) {
-    const result = [];
-    for (const filepath of files) {
+export async function collectFiles(paths) {
+    const files = [];
+    for (const filepath of paths) {
         const file = {
             filepath,
             suites: [],
@@ -54,13 +46,37 @@ export async function collectFiles(files) {
             file.collected = false;
             process.exitCode = 1;
         }
-        result.push(file);
+        files.push(file);
+    }
+    const allSuites = files.reduce((suites, file) => suites.concat(file.suites), []);
+    interpretOnlyMode(allSuites);
+    allSuites.forEach((i) => {
+        if (i.mode === 'skip')
+            i.tasks.forEach(t => t.mode === 'run' && (t.state = 'skip'));
+        else
+            interpretOnlyMode(i.tasks);
+    });
+    return files;
+}
+/**
+ * If any items been marked as `only`, mark all other items as `skip`.
+ */
+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';
+        });
     }
-    return result;
 }
 export async function runFile(file, ctx) {
     var _a, _b, _c, _d;
     const { reporter } = ctx;
+    const runableSuites = file.suites.filter(i => i.mode === 'run');
+    if (runableSuites.length === 0)
+        return;
     await ((_a = reporter.onFileBegin) === null || _a === void 0 ? void 0 : _a.call(reporter, file, ctx));
     await beforeFileHook.fire(file);
     for (const suite of file.suites) {
@@ -74,42 +90,39 @@ export async function runFile(file, ctx) {
     await afterFileHook.fire(file);
     await ((_d = reporter.onFileEnd) === null || _d === void 0 ? void 0 : _d.call(reporter, file, ctx));
 }
-export async function run(options = {}) {
-    var _a, _b, _c;
-    const { rootDir = process.cwd() } = options;
+export async function run(config) {
+    var _a, _b, _c, _d;
     // setup chai
-    chai.use(await SnapshotPlugin({
-        rootDir,
-        update: options.updateSnapshot,
-    }));
-    chai.use(SinonChai);
+    await setupChai(config);
     // collect files
-    const paths = await fg(options.includes || defaultIncludes, {
+    let paths = await fg(config.includes || defaultIncludes, {
         absolute: true,
-        cwd: options.rootDir,
-        ignore: options.excludes || defaultExcludes,
+        cwd: config.rootDir,
+        ignore: config.excludes || defaultExcludes,
     });
+    if ((_a = config.nameFilters) === null || _a === void 0 ? void 0 : _a.length)
+        paths = paths.filter(i => config.nameFilters.some(f => i.includes(f)));
     if (!paths.length) {
         console.error('No test files found');
         process.exitCode = 1;
         return;
     }
     const reporter = new DefaultReporter();
-    await ((_a = reporter.onStart) === null || _a === void 0 ? void 0 : _a.call(reporter, options));
+    await ((_b = reporter.onStart) === null || _b === void 0 ? void 0 : _b.call(reporter, config));
+    if (config.global)
+        (await import('./global')).registerApiGlobally();
+    if (config.jsdom)
+        (await import('./integrations/jsdom')).setupJSDOM(globalThis);
     const files = await collectFiles(paths);
     const ctx = {
         files,
-        mode: isOnlyMode(files) ? 'only' : 'all',
-        userOptions: options,
+        config,
         reporter,
     };
-    await ((_b = reporter.onCollected) === null || _b === void 0 ? void 0 : _b.call(reporter, ctx));
+    await ((_c = reporter.onCollected) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
     await beforeAllHook.fire();
     for (const file of files)
         await runFile(file, ctx);
     await afterAllHook.fire();
-    await ((_c = reporter.onFinished) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
-}
-function isOnlyMode(files) {
-    return !!files.find(file => file.suites.find(suite => suite.mode === 'only' || suite.tasks.find(t => t.mode === 'only')));
+    await ((_d = reporter.onFinished) === null || _d === void 0 ? void 0 : _d.call(reporter, ctx));
 }

package/dist/suite.js

@@ -22,7 +22,7 @@ function createSuiteCollector(mode, suiteName, factory) {
             name,
             mode,
             suite: {},
-            status: 'init',
+            state: mode !== 'run' ? mode : undefined,
             fn,
         });
     }

package/dist/types.d.ts

@@ -1,21 +1,37 @@
+import { ViteDevServer } from 'vite';
 export declare type Awaitable<T> = Promise<T> | T;
 export interface UserOptions {
     includes?: string[];
     excludes?: string[];
+    /**
+     * Register apis globally
+     *
+     * @default false
+     */
+    global?: boolean;
+    /**
+     * Use `js-dom` to mock browser APIs
+     *
+     * @default false
+     */
+    jsdom?: boolean;
 }
-export interface Options extends UserOptions {
+export interface Config extends UserOptions {
     rootDir?: string;
     updateSnapshot?: boolean;
+    nameFilters?: string[];
+    server: ViteDevServer;
+    watch?: boolean;
 }
 export declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
-export declare type TaskStatus = 'init' | 'pass' | 'fail' | 'skip' | 'todo';
+export declare type TaskState = RunMode | 'pass' | 'fail';
 export interface Task {
     name: string;
     mode: RunMode;
     suite: Suite;
     fn: () => Awaitable<void>;
     file?: File;
-    status: TaskStatus;
+    state?: TaskState;
     error?: unknown;
 }
 export declare type TestFunction = () => Awaitable<void>;
@@ -47,8 +63,7 @@ export interface File {
 }
 export interface RunnerContext {
     files: File[];
-    mode: 'all' | 'only';
-    userOptions: Options;
+    config: Config;
     reporter: Reporter;
 }
 export interface GlobalContext {
@@ -56,7 +71,7 @@ export interface GlobalContext {
     currentSuite: SuiteCollector | null;
 }
 export interface Reporter {
-    onStart: (userOptions: Options) => Awaitable<void>;
+    onStart: (userOptions: Config) => Awaitable<void>;
     onCollected: (ctx: RunnerContext) => Awaitable<void>;
     onFinished: (ctx: RunnerContext) => Awaitable<void>;
     onSuiteBegin: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;

package/dist/types.js

@@ -1,2 +1 @@
-/* eslint-disable no-use-before-define */
 export {};

package/global.d.ts

@@ -0,0 +1,21 @@
+declare global {
+  const suite: typeof import('vitest')['suite']
+  const test: typeof import('vitest')['test']
+  const describe: typeof import('vitest')['describe']
+  const it: typeof import('vitest')['it']
+  const expect: typeof import('vitest')['expect']
+  const assert: typeof import('vitest')['assert']
+  const spy: typeof import('vitest')['spy']
+  const mock: typeof import('vitest')['mock']
+  const stub: typeof import('vitest')['stub']
+  const sinon: typeof import('vitest')['sinon']
+  const beforeAll: typeof import('vitest')['beforeAll']
+  const afterAll: typeof import('vitest')['afterAll']
+  const beforeEach: typeof import('vitest')['beforeEach']
+  const afterEach: typeof import('vitest')['afterEach']
+  const beforeFile: typeof import('vitest')['beforeFile']
+  const afterFile: typeof import('vitest')['afterFile']
+  const beforeSuite: typeof import('vitest')['beforeSuite']
+  const afterSuite: typeof import('vitest')['afterSuite']
+}
+export {}

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.11",
-  "type": "module",
+  "version": "0.0.15",
   "description": "",
   "keywords": [],
   "homepage": "https://github.com/antfu/vitest#readme",
@@ -15,6 +14,7 @@
   "funding": "https://github.com/sponsors/antfu",
   "license": "MIT",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "type": "module",
   "exports": {
     ".": {
       "import": "./dist/index.js",
@@ -25,33 +25,23 @@
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": [
-    "dist",
-    "bin"
-  ],
   "bin": {
     "vitest": "./bin/vitest.mjs"
   },
+  "files": [
+    "dist",
+    "bin",
+    "*.d.ts"
+  ],
   "scripts": {
-    "build": "tsc",
-    "watch": "tsc --watch",
+    "prepare": "esmo scripts/generate-types.ts",
+    "build": "rimraf dist && tsc -p src/tsconfig.json",
     "lint": "eslint \"{src,test}/**/*.ts\"",
     "prepublishOnly": "nr build",
     "release": "bumpp --commit --push --tag && pnpm publish",
     "test": "node bin/vitest.mjs --dev",
-    "test:update": "nr test -u"
-  },
-  "devDependencies": {
-    "@antfu/eslint-config": "^0.11.1",
-    "@antfu/ni": "^0.11.0",
-    "@types/minimist": "^1.2.2",
-    "@types/node": "^16.11.11",
-    "@types/sinon": "^10.0.6",
-    "bumpp": "^7.1.1",
-    "eslint": "^8.3.0",
-    "esno": "^0.12.1",
-    "typescript": "^4.5.2",
-    "vite": "^2.6.14"
+    "test:update": "nr test -u",
+    "watch": "tsc -p src/tsconfig.json --watch"
   },
   "dependencies": {
     "@jest/test-result": "^27.4.2",
@@ -62,11 +52,25 @@
     "find-up": "^6.2.0",
     "jest-snapshot": "^27.4.2",
     "jest-util": "^27.4.2",
+    "jsdom": "^19.0.0",
     "minimist": "^1.2.5",
     "ora": "^6.0.1",
     "picocolors": "^1.0.0",
     "sinon": "^12.0.1",
-    "sinon-chai": "^3.7.0",
-    "vite-node": "^0.1.10"
+    "sinon-chai": "^3.7.0"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^0.11.1",
+    "@antfu/ni": "^0.11.0",
+    "@types/jsdom": "^16.2.13",
+    "@types/minimist": "^1.2.2",
+    "@types/node": "^16.11.11",
+    "@types/sinon": "^10.0.6",
+    "bumpp": "^7.1.1",
+    "eslint": "^8.3.0",
+    "esno": "^0.12.1",
+    "rimraf": "^3.0.2",
+    "typescript": "^4.5.2",
+    "vite": "^2.6.14"
   }
 }

package/dist/defaultIncludes.js

@@ -1 +0,0 @@
-"use strict";

package/dist/snapshot/index.d.ts

@@ -1,9 +0,0 @@
-import { use as chaiUse } from 'chai';
-declare type FirstFunctionArgument<T> = T extends (arg: infer A) => unknown ? A : never;
-declare type ChaiPlugin = FirstFunctionArgument<typeof chaiUse>;
-export interface SnapshotOptions {
-    rootDir: string;
-    update?: boolean;
-}
-export declare function SnapshotPlugin(options: SnapshotOptions): Promise<ChaiPlugin>;
-export {};

package/dist/snapshot/utils/SnapshotResult.js

@@ -1 +0,0 @@
-"use strict";

package/dist/snapshot/utils/tyoes.js

@@ -1 +0,0 @@
-"use strict";