vitest 0.0.19 → 0.0.23

package/README.md

@@ -2,7 +2,7 @@
 
 [![NPM version](https://img.shields.io/npm/v/vitest?color=a1b858&label=)](https://www.npmjs.com/package/vitest)
 
-A blazing fast test runner powered by Vite.
+A blazing fast unit test framework powered by Vite.
 
 ## Features
 
@@ -155,10 +155,10 @@ describe('suite', () => {
 - [x] Task filter
 - [x] Mock
 - [x] Global Mode & Types
-- [ ] Parallel Executing
-- [ ] CLI Help
-- [ ] JSDom
-- [ ] Watch
+- [ ] Concurrent Executing
+- [x] CLI Help
+- [x] JSDom
+- [x] Watch
 - [ ] Source Map
 - [ ] Coverage
 

package/bin/vitest.mjs

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
 'use strict'
 
-import '../dist/entry.js'
+import '../dist/cli.js'

package/dist/cli.d.ts

@@ -1 +1,10 @@
-export {};
+import type { UserOptions } from './types';
+declare global {
+    namespace NodeJS {
+        interface Process {
+            __vitest__: {
+                options: Required<UserOptions>;
+            };
+        }
+    }
+}

package/dist/cli.js

@@ -1,29 +1,56 @@
-var _a;
-import minimist from 'minimist';
-import c from 'picocolors';
-import { run } from './run';
-const { log } = console;
-const argv = minimist(process.argv.slice(2), {
-    alias: {
-        u: 'update',
-        w: 'watch',
-    },
-    string: ['root', 'config'],
-    boolean: ['update', 'dev', 'global', 'watch', 'jsdom'],
-    unknown(name) {
-        if (name[0] === '-') {
-            console.error(c.red(`Unknown argument: ${name}`));
-            help();
-            process.exit(1);
-        }
-        return true;
-    },
-});
-// @ts-expect-error
-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(Object.assign({}, argv), testOptions), { server, updateSnapshot: argv.update, rootDir: argv.root || process.cwd(), nameFilters: argv._ }));
-function help() {
-    log('Help: finish help');
-}
+import { fileURLToPath } from 'url';
+import { resolve, dirname } from 'path';
+import { findUp } from 'find-up';
+import sade from 'sade';
+import { run as startViteNode } from './node/index.js';
+// TODO: use bundler
+const version = '0.0.0';
+sade('vitest [filter]', true)
+    .version(version)
+    .describe('A blazing fast unit test framework powered by Vite.')
+    .option('-r, --root', 'root path', process.cwd())
+    .option('-c, --config', 'path to config file')
+    .option('-w, --watch', 'watch mode', false)
+    .option('-u, --update', 'update snapshot', false)
+    .option('--global', 'inject apis globally', false)
+    .option('--dev', 'dev mode', false)
+    .option('--jsdom', 'mock browser api using JSDOM', false)
+    .action(async (filters, options) => {
+    process.env.VITEST = 'true';
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const root = resolve(options.root || process.cwd());
+    const configPath = options.config
+        ? resolve(root, options.config)
+        : await findUp(['vitest.config.ts', 'vitest.config.js', 'vitest.config.mjs', 'vite.config.ts', 'vite.config.js', 'vite.config.mjs'], { cwd: root });
+    options.config = configPath;
+    options.root = root;
+    options.filters = filters
+        ? Array.isArray(filters)
+            ? filters
+            : [filters]
+        : undefined;
+    process.__vitest__ = {
+        options,
+    };
+    await startViteNode({
+        root,
+        files: [
+            resolve(__dirname, options.dev ? '../src/entry.ts' : './entry.js'),
+        ],
+        config: configPath,
+        defaultConfig: {
+            optimizeDeps: {
+                exclude: [
+                    'vitest',
+                ],
+            },
+        },
+        shouldExternalize(id) {
+            if (id.includes('/node_modules/vitest/'))
+                return false;
+            else
+                return id.includes('/node_modules/');
+        },
+    });
+})
+    .parse(process.argv);

package/dist/entry.js

@@ -1,38 +1,6 @@
-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/');
-    },
-});
+import { run } from './run';
+if (!process.__vite_node__ || !process.__vitest__)
+    throw new Error('Vitest can only run in vite-node environment, please use the CLI to start the process');
+const inlineOptions = process.__vite_node__.server.config.test || {};
+const cliOptions = process.__vitest__.options || {};
+await run(Object.assign(Object.assign({}, inlineOptions), cliOptions));

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

@@ -19,7 +19,7 @@ export function JestChaiExpect() {
             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 () {
+        utils.addMethod(proto, 'toBeFalsy', function () {
             const obj = utils.flag(this, 'object');
             this.assert(!obj, 'expected #{this} to be falsy', 'expected #{this} to not be falsy', obj);
         });

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

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

package/dist/integrations/chai/setup.js

@@ -5,8 +5,5 @@ 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,
-    }));
+    chai.use(await SnapshotPlugin(config));
 }

package/dist/integrations/chai/snapshot/index.d.ts

@@ -1,7 +1,7 @@
 import { ChaiPlugin } from '../types';
 import { SnapshotManager } from './manager';
 export interface SnapshotOptions {
-    rootDir: string;
+    root: string;
     update?: boolean;
 }
 export declare function getSnapshotManager(): SnapshotManager;

package/dist/integrations/chai/snapshot/index.js

@@ -6,7 +6,7 @@ export function getSnapshotManager() {
     return _manager;
 }
 export async function SnapshotPlugin(options) {
-    const { rootDir } = options;
+    const { root: rootDir } = options;
     _manager = new SnapshotManager({
         rootDir,
         update: options.update,

package/dist/integrations/{jsdom.js → jsdom/index.js}

@@ -1,4 +1,5 @@
 import { JSDOM } from 'jsdom';
+import { KEYS } from './keys';
 export function setupJSDOM(global) {
     const dom = new JSDOM('<!DOCTYPE html>', {
         pretendToBeVisual: true,
@@ -6,7 +7,7 @@ export function setupJSDOM(global) {
         // TODO: options
         url: 'http://localhost:3000',
     });
-    const keys = Object.getOwnPropertyNames(dom.window)
+    const keys = KEYS.concat(Object.getOwnPropertyNames(dom.window))
         .filter(k => !k.startsWith('_'))
         .filter(k => !(k in global));
     for (const key of keys)

package/dist/integrations/jsdom/keys.d.ts

@@ -0,0 +1 @@
+export declare const KEYS: string[];

package/dist/integrations/jsdom/keys.js

@@ -0,0 +1,220 @@
+// SEE https://github.com/jsdom/jsdom/blob/master/lib/jsdom/living/interfaces.js
+const LIVING_KEYS = [
+    'DOMException',
+    'URL',
+    'URLSearchParams',
+    'EventTarget',
+    'NamedNodeMap',
+    'Node',
+    'Attr',
+    'Element',
+    'DocumentFragment',
+    'DOMImplementation',
+    'Document',
+    'XMLDocument',
+    'CharacterData',
+    'Text',
+    'CDATASection',
+    'ProcessingInstruction',
+    'Comment',
+    'DocumentType',
+    'NodeList',
+    'HTMLCollection',
+    'HTMLOptionsCollection',
+    'DOMStringMap',
+    'DOMTokenList',
+    'StyleSheetList',
+    'HTMLElement',
+    'HTMLHeadElement',
+    'HTMLTitleElement',
+    'HTMLBaseElement',
+    'HTMLLinkElement',
+    'HTMLMetaElement',
+    'HTMLStyleElement',
+    'HTMLBodyElement',
+    'HTMLHeadingElement',
+    'HTMLParagraphElement',
+    'HTMLHRElement',
+    'HTMLPreElement',
+    'HTMLUListElement',
+    'HTMLOListElement',
+    'HTMLLIElement',
+    'HTMLMenuElement',
+    'HTMLDListElement',
+    'HTMLDivElement',
+    'HTMLAnchorElement',
+    'HTMLAreaElement',
+    'HTMLBRElement',
+    'HTMLButtonElement',
+    'HTMLCanvasElement',
+    'HTMLDataElement',
+    'HTMLDataListElement',
+    'HTMLDetailsElement',
+    'HTMLDialogElement',
+    'HTMLDirectoryElement',
+    'HTMLFieldSetElement',
+    'HTMLFontElement',
+    'HTMLFormElement',
+    'HTMLHtmlElement',
+    'HTMLImageElement',
+    'HTMLInputElement',
+    'HTMLLabelElement',
+    'HTMLLegendElement',
+    'HTMLMapElement',
+    'HTMLMarqueeElement',
+    'HTMLMediaElement',
+    'HTMLMeterElement',
+    'HTMLModElement',
+    'HTMLOptGroupElement',
+    'HTMLOptionElement',
+    'HTMLOutputElement',
+    'HTMLPictureElement',
+    'HTMLProgressElement',
+    'HTMLQuoteElement',
+    'HTMLScriptElement',
+    'HTMLSelectElement',
+    'HTMLSlotElement',
+    'HTMLSourceElement',
+    'HTMLSpanElement',
+    'HTMLTableCaptionElement',
+    'HTMLTableCellElement',
+    'HTMLTableColElement',
+    'HTMLTableElement',
+    'HTMLTimeElement',
+    'HTMLTableRowElement',
+    'HTMLTableSectionElement',
+    'HTMLTemplateElement',
+    'HTMLTextAreaElement',
+    'HTMLUnknownElement',
+    'HTMLFrameElement',
+    'HTMLFrameSetElement',
+    'HTMLIFrameElement',
+    'HTMLEmbedElement',
+    'HTMLObjectElement',
+    'HTMLParamElement',
+    'HTMLVideoElement',
+    'HTMLAudioElement',
+    'HTMLTrackElement',
+    'SVGElement',
+    'SVGGraphicsElement',
+    'SVGSVGElement',
+    'SVGTitleElement',
+    'SVGAnimatedString',
+    'SVGNumber',
+    'SVGStringList',
+    'Event',
+    'CloseEvent',
+    'CustomEvent',
+    'MessageEvent',
+    'ErrorEvent',
+    'HashChangeEvent',
+    'PopStateEvent',
+    'StorageEvent',
+    'ProgressEvent',
+    'PageTransitionEvent',
+    'UIEvent',
+    'FocusEvent',
+    'InputEvent',
+    'MouseEvent',
+    'KeyboardEvent',
+    'TouchEvent',
+    'CompositionEvent',
+    'WheelEvent',
+    'BarProp',
+    'External',
+    'Location',
+    'History',
+    'Screen',
+    'Performance',
+    'Navigator',
+    'PluginArray',
+    'MimeTypeArray',
+    'Plugin',
+    'MimeType',
+    'FileReader',
+    'Blob',
+    'File',
+    'FileList',
+    'ValidityState',
+    'DOMParser',
+    'XMLSerializer',
+    'FormData',
+    'XMLHttpRequestEventTarget',
+    'XMLHttpRequestUpload',
+    'XMLHttpRequest',
+    'WebSocket',
+    'NodeFilter',
+    'NodeIterator',
+    'TreeWalker',
+    'AbstractRange',
+    'Range',
+    'StaticRange',
+    'Selection',
+    'Storage',
+    'CustomElementRegistry',
+    'ShadowRoot',
+    'MutationObserver',
+    'MutationRecord',
+    'Headers',
+    'AbortController',
+    'AbortSignal',
+];
+const OTHER_KEYS = [
+    'addEventListener',
+    'alert',
+    'atob',
+    'blur',
+    'btoa',
+    /* 'clearInterval', */
+    /* 'clearTimeout', */
+    'close',
+    'confirm',
+    /* 'console', */
+    'createPopup',
+    'dispatchEvent',
+    'document',
+    'focus',
+    'frames',
+    'getComputedStyle',
+    'history',
+    'innerHeight',
+    'innerWidth',
+    'length',
+    'location',
+    'moveBy',
+    'moveTo',
+    'name',
+    'navigator',
+    'open',
+    'outerHeight',
+    'outerWidth',
+    'pageXOffset',
+    'pageYOffset',
+    'parent',
+    'postMessage',
+    'print',
+    'prompt',
+    'removeEventListener',
+    'resizeBy',
+    'resizeTo',
+    'screen',
+    'screenLeft',
+    'screenTop',
+    'screenX',
+    'screenY',
+    'scroll',
+    'scrollBy',
+    'scrollLeft',
+    'scrollTo',
+    'scrollTop',
+    'scrollX',
+    'scrollY',
+    'self',
+    /* 'setInterval', */
+    /* 'setTimeout', */
+    'stop',
+    /* 'toString', */
+    'top',
+    'window',
+];
+export const KEYS = LIVING_KEYS.concat(OTHER_KEYS);

package/dist/node/index.d.ts

@@ -0,0 +1,22 @@
+import { InlineConfig, ViteDevServer } from 'vite';
+declare global {
+    namespace NodeJS {
+        interface Process {
+            __vite_node__: {
+                server: ViteDevServer;
+                watch?: boolean;
+                moduleCache: Map<string, Promise<any>>;
+            };
+        }
+    }
+}
+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 → node/index.js}

@@ -5,6 +5,7 @@ import vm from 'vm';
 import { createServer, mergeConfig } from 'vite';
 import c from 'picocolors';
 const { red, dim, yellow } = c;
+const __pendingModules__ = new Map();
 export async function run(argv) {
     process.exitCode = 0;
     const root = argv.root || process.cwd();
@@ -19,9 +20,9 @@ export async function run(argv) {
         resolve: {},
     }));
     await server.pluginContainer.buildStart({});
-    // @ts-expect-error
     process.__vite_node__ = {
         server,
+        moduleCache: __pendingModules__,
     };
     try {
         await execute(files, server, argv);
@@ -31,7 +32,8 @@ export async function run(argv) {
         throw e;
     }
     finally {
-        await server.close();
+        if (!process.__vite_node__.watch)
+            await server.close();
     }
 }
 function normalizeId(id) {
@@ -47,7 +49,9 @@ function toFilePath(id, server) {
         ? id.slice(4)
         : id.startsWith(dirname(server.config.root))
             ? id
-            : slash(resolve(server.config.root, id.slice(1)));
+            : id.startsWith('/')
+                ? slash(resolve(server.config.root, id.slice(1)))
+                : id;
     if (absolute.startsWith('//'))
         absolute = absolute.slice(1);
     if (!absolute.startsWith('/'))
@@ -55,15 +59,12 @@ function toFilePath(id, server) {
     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];
+    async function directRequest(id, fsPath, callstack) {
+        callstack = [...callstack, id];
         const request = async (dep) => {
             if (callstack.includes(dep)) {
                 throw new Error(`${red('Circular dependency detected')}\nStack:\n${[...callstack, dep].reverse().map((i) => {
@@ -73,19 +74,15 @@ async function execute(files, server, options) {
             }
             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 url = pathToFileURL(fsPath);
         const exports = {};
         const context = {
             require: createRequire(url),
-            __filename: absolute,
-            __dirname: dirname(absolute),
+            __filename: fsPath,
+            __dirname: dirname(fsPath),
             __vite_ssr_import__: request,
             __vite_ssr_dynamic_import__: request,
             __vite_ssr_exports__: exports,
@@ -93,17 +90,23 @@ async function execute(files, server, options) {
             __vite_ssr_import_meta__: { url },
         };
         const fn = vm.runInThisContext(`async (${Object.keys(context).join(',')}) => { ${result.code} }`, {
-            filename: absolute,
+            filename: fsPath,
             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);
+    async function cachedRequest(rawId, callstack) {
+        if (builtinModules.includes(rawId))
+            return import(rawId);
+        const id = normalizeId(rawId);
+        const fsPath = toFilePath(id, server);
+        if (options.shouldExternalize(fsPath))
+            return import(fsPath);
+        if (__pendingModules__.has(fsPath))
+            return __pendingModules__.get(fsPath);
+        __pendingModules__.set(fsPath, directRequest(id, fsPath, callstack));
+        return await __pendingModules__.get(fsPath);
     }
     function exportAll(exports, sourceModule) {
         // eslint-disable-next-line no-restricted-syntax

package/dist/reporters/default.d.ts

@@ -1,24 +1,21 @@
 import Listr from 'listr';
-import { Reporter, RunnerContext, Task } from '../types';
+import { File, Reporter, RunnerContext, Task } from '../types';
 interface TaskPromise {
     promise: Promise<void>;
     resolve: () => void;
     reject: (e: unknown) => void;
 }
 export declare class DefaultReporter implements Reporter {
-    indent: number;
     start: number;
     end: number;
     listr: Listr | null;
     listrPromise: Promise<void> | null;
     taskMap: Map<Task, TaskPromise>;
-    onStart(): void;
-    onCollected(ctx: RunnerContext): void;
+    onCollected(files: File[]): void;
     onTaskEnd(task: Task): void;
-    onFinished({ files }: RunnerContext): Promise<void>;
-    private getIndent;
-    private log;
-    private error;
+    onFinished(ctx: RunnerContext): Promise<void>;
+    onWatcherStart(ctx: RunnerContext): Promise<void>;
+    onWatcherRerun(files: string[], trigger: string): Promise<void>;
     onSnapshotUpdate(): void;
 }
 export {};

package/dist/reporters/default.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 import { performance } from 'perf_hooks';
 import { relative } from 'path';
 import c from 'picocolors';
@@ -5,20 +6,16 @@ import Listr from 'listr';
 const CROSS = '✖ ';
 export class DefaultReporter {
     constructor() {
-        this.indent = 0;
         this.start = 0;
         this.end = 0;
         this.listr = null;
         this.listrPromise = null;
         this.taskMap = new Map();
     }
-    onStart() {
-        this.indent = 0;
-    }
-    onCollected(ctx) {
+    onCollected(files) {
         this.start = performance.now();
         this.taskMap = new Map();
-        const tasks = ctx.files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
+        const tasks = files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
         tasks.forEach((t) => {
             const obj = {};
             obj.promise = new Promise((resolve, reject) => {
@@ -42,7 +39,7 @@ export class DefaultReporter {
         const listrOptions = {
             exitOnError: false,
         };
-        this.listr = new Listr(ctx.files.map((file) => {
+        this.listr = new Listr(files.map((file) => {
             return {
                 title: relative(process.cwd(), file.filepath),
                 task: () => {
@@ -67,12 +64,11 @@ export class DefaultReporter {
         else
             (_b = this.taskMap.get(task)) === null || _b === void 0 ? void 0 : _b.resolve();
     }
-    async onFinished({ files }) {
+    async onFinished(ctx) {
         await this.listrPromise;
-        this.log();
         this.end = performance.now();
-        const suites = files.reduce((acc, file) => acc.concat(file.suites), []);
-        const tasks = files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
+        console.log();
+        const { tasks, suites, files } = ctx;
         const failedFiles = files.filter(i => i.error);
         const failedSuites = suites.filter(i => i.error);
         const runable = tasks.filter(i => i.state === 'pass' || i.state === 'fail');
@@ -80,53 +76,54 @@ export class DefaultReporter {
         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:`));
+            console.error(c.bold(`\nFailed to parse ${failedFiles.length} files:`));
             failedFiles.forEach((i) => {
-                this.error(`\n- ${i.filepath}`);
+                console.error(c.red(`\n- ${i.filepath}`));
                 console.error(i.error || 'Unknown error');
-                this.log();
+                console.log();
             });
         }
         if (failedSuites.length) {
-            this.error(c.bold(`\nFailed to run ${failedSuites.length} suites:`));
+            console.error(c.bold(`\nFailed to run ${failedSuites.length} suites:`));
             failedSuites.forEach((i) => {
                 var _a;
-                this.error(`\n- ${(_a = i.file) === null || _a === void 0 ? void 0 : _a.filepath} > ${i.name}`);
+                console.error(c.red(`\n- ${(_a = i.file) === null || _a === void 0 ? void 0 : _a.filepath} > ${i.name}`));
                 console.error(i.error || 'Unknown error');
-                this.log();
+                console.log();
             });
         }
         if (failed.length) {
-            this.error(c.bold(`\nFailed Tests (${failed.length})`));
+            console.error(c.bold(`\nFailed Tests (${failed.length})`));
             failed.forEach((task) => {
                 var _a;
-                this.error(`\n${CROSS + c.inverse(c.red(' FAIL '))} ${[task.suite.name, task.name].filter(Boolean).join(' > ')} ${c.gray(c.dim(`${(_a = task.file) === null || _a === void 0 ? void 0 : _a.filepath}`))}`);
+                console.error(`\n${CROSS + c.inverse(c.red(' FAIL '))} ${[task.suite.name, task.name].filter(Boolean).join(' > ')} ${c.gray(c.dim(`${(_a = task.file) === null || _a === void 0 ? void 0 : _a.filepath}`))}`);
                 console.error(task.error || 'Unknown error');
-                this.log();
+                console.log();
             });
         }
-        this.log(c.bold(c.green(`Passed   ${passed.length} / ${runable.length}`)));
+        console.log(c.bold(c.green(`Passed   ${passed.length} / ${runable.length}`)));
         if (failed.length)
-            this.log(c.bold(c.red(`Failed   ${failed.length} / ${runable.length}`)));
+            console.log(c.bold(c.red(`Failed   ${failed.length} / ${runable.length}`)));
         if (skipped.length)
-            this.log(c.yellow(`Skipped  ${skipped.length}`));
+            console.log(c.yellow(`Skipped  ${skipped.length}`));
         if (todo.length)
-            this.log(c.dim(`Todo     ${todo.length}`));
-        this.log(`Time     ${(this.end - this.start).toFixed(2)}ms`);
-    }
-    getIndent(offest = 0) {
-        return ' '.repeat((this.indent + offest) * 2);
+            console.log(c.dim(`Todo     ${todo.length}`));
+        console.log(`Time     ${(this.end - this.start).toFixed(2)}ms`);
     }
-    log(msg = '', indentOffset = 0) {
-        // eslint-disable-next-line no-console
-        console.log(`${this.getIndent(indentOffset)}${msg}`);
+    async onWatcherStart(ctx) {
+        await this.listrPromise;
+        const failed = ctx.tasks.some(i => i.state === 'fail');
+        if (failed)
+            console.log(c.red('\nTests failed. Watching for file changes...'));
+        else
+            console.log(c.green('\nWatching for file changes...'));
     }
-    error(msg = '', indentOffset = 0) {
-        // eslint-disable-next-line no-console
-        console.error(c.red(`${this.getIndent(indentOffset)}${msg}`));
+    async onWatcherRerun(files, trigger) {
+        await this.listrPromise;
+        console.log(c.blue(`File ${relative(process.cwd(), trigger)} changed, re-running tests...`));
     }
+    // TODO:
     onSnapshotUpdate() {
     }
 }

package/dist/run/index.d.ts

@@ -0,0 +1,8 @@
+import { File, ResolvedConfig, Task, RunnerContext, Suite } from '../types';
+export declare function runTask(task: Task, ctx: RunnerContext): Promise<void>;
+export declare function collectFiles(paths: string[]): Promise<Record<string, File>>;
+export declare function runSite(suite: Suite, ctx: RunnerContext): Promise<void>;
+export declare function runFile(file: File, ctx: RunnerContext): Promise<void>;
+export declare function runFiles(filesMap: Record<string, File>, ctx: RunnerContext): Promise<void>;
+export declare function run(config: ResolvedConfig): Promise<void>;
+export declare function startWatcher(ctx: RunnerContext): Promise<void>;

package/dist/{run.js → run/index.js}

@@ -1,10 +1,10 @@
 import fg from 'fast-glob';
-import { setupChai } from './integrations/chai/setup';
-import { clearContext, defaultSuite } from './suite';
-import { context } from './context';
-import { DefaultReporter } from './reporters/default';
-import { defaultIncludes, defaultExcludes } from './constants';
-import { getSnapshotManager } from './integrations/chai/snapshot';
+import { setupChai } from '../integrations/chai/setup';
+import { clearContext, defaultSuite } from '../suite';
+import { context } from '../context';
+import { DefaultReporter } from '../reporters/default';
+import { defaultIncludes, defaultExcludes } from '../constants';
+import { getSnapshotManager } from '../integrations/chai/snapshot';
 async function callHook(suite, name, args) {
     await Promise.all(suite.hooks[name].map(fn => fn(...args)));
 }
@@ -36,7 +36,7 @@ export async function runTask(task, ctx) {
     await ((_c = reporter.onTaskEnd) === null || _c === void 0 ? void 0 : _c.call(reporter, task, ctx));
 }
 export async function collectFiles(paths) {
-    const files = [];
+    const files = {};
     for (const filepath of paths) {
         const file = {
             filepath,
@@ -58,9 +58,10 @@ export async function collectFiles(paths) {
             file.collected = false;
             process.exitCode = 1;
         }
-        files.push(file);
+        files[filepath] = file;
     }
-    const allSuites = files.reduce((suites, file) => suites.concat(file.suites), []);
+    const allFiles = Object.values(files);
+    const allSuites = allFiles.reduce((suites, file) => suites.concat(file.suites), []);
     interpretOnlyMode(allSuites);
     allSuites.forEach((i) => {
         if (i.mode === 'skip')
@@ -125,40 +126,111 @@ export async function runFile(file, ctx) {
     }
     await ((_b = reporter.onFileEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, file, ctx));
 }
+export async function runFiles(filesMap, ctx) {
+    var _a;
+    const { reporter } = ctx;
+    await ((_a = reporter.onCollected) === null || _a === void 0 ? void 0 : _a.call(reporter, Object.values(filesMap), ctx));
+    for (const file of Object.values(filesMap))
+        await runFile(file, ctx);
+}
 export async function run(config) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
+    // if watch, tell `vite-node` not to end the process
+    if (config.watch)
+        process.__vite_node__.watch = true;
     // setup chai
     await setupChai(config);
     // collect files
-    let paths = await fg(config.includes || defaultIncludes, {
+    let testFilepaths = await fg(config.includes || defaultIncludes, {
         absolute: true,
-        cwd: config.rootDir,
+        cwd: config.root,
         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) {
+    // if name filters are provided by the CLI
+    if ((_a = config.filters) === null || _a === void 0 ? void 0 : _a.length)
+        testFilepaths = testFilepaths.filter(i => config.filters.some(f => i.includes(f)));
+    if (!testFilepaths.length) {
         console.error('No test files found');
         process.exitCode = 1;
         return;
     }
-    const reporter = new DefaultReporter();
-    await ((_b = reporter.onStart) === null || _b === void 0 ? void 0 : _b.call(reporter, config));
+    // setup envs
     if (config.global)
-        (await import('./global')).registerApiGlobally();
+        (await import('../global')).registerApiGlobally();
     if (config.jsdom)
-        (await import('./integrations/jsdom')).setupJSDOM(globalThis);
-    const files = await collectFiles(paths);
+        (await import('../integrations/jsdom')).setupJSDOM(globalThis);
+    const reporter = new DefaultReporter();
+    await ((_b = reporter.onStart) === null || _b === void 0 ? void 0 : _b.call(reporter, config));
+    const filesMap = await collectFiles(testFilepaths);
     const ctx = {
-        files,
+        filesMap,
+        get files() {
+            return Object.values(this.filesMap);
+        },
+        get suites() {
+            return Object.values(this.filesMap)
+                .reduce((suites, file) => suites.concat(file.suites), []);
+        },
+        get tasks() {
+            return this.suites
+                .reduce((tasks, suite) => tasks.concat(suite.tasks), []);
+        },
         config,
         reporter,
     };
-    await ((_c = reporter.onCollected) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
-    for (const file of files)
-        await runFile(file, ctx);
+    await runFiles(filesMap, ctx);
     const snapshot = getSnapshotManager();
     snapshot === null || snapshot === void 0 ? void 0 : snapshot.saveSnap();
     snapshot === null || snapshot === void 0 ? void 0 : snapshot.report();
-    await ((_d = reporter.onFinished) === null || _d === void 0 ? void 0 : _d.call(reporter, ctx));
+    await ((_c = reporter.onFinished) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
+    if (config.watch)
+        startWatcher(ctx);
+}
+export async function startWatcher(ctx) {
+    var _a, _b;
+    await ((_b = (_a = ctx.reporter).onWatcherStart) === null || _b === void 0 ? void 0 : _b.call(_a, ctx));
+    let timer;
+    const changedTests = new Set();
+    const seen = new Set();
+    const { server, moduleCache } = process.__vite_node__;
+    server.watcher.on('change', async (id) => {
+        getDependencyTests(id, ctx, changedTests, seen);
+        seen.forEach(i => moduleCache.delete(i));
+        seen.clear();
+        if (changedTests.size === 0)
+            return;
+        clearTimeout(timer);
+        timer = setTimeout(async () => {
+            var _a, _b, _c, _d;
+            const snapshot = getSnapshotManager();
+            const pathes = Array.from(changedTests);
+            changedTests.clear();
+            await ((_b = (_a = ctx.reporter).onWatcherRerun) === null || _b === void 0 ? void 0 : _b.call(_a, pathes, id, ctx));
+            pathes.forEach(i => moduleCache.delete(i));
+            const files = await collectFiles(pathes);
+            Object.assign(ctx.filesMap, files);
+            await runFiles(files, ctx);
+            // TODO: clear snapshot state
+            snapshot === null || snapshot === void 0 ? void 0 : snapshot.saveSnap();
+            snapshot === null || snapshot === void 0 ? void 0 : snapshot.report();
+            await ((_d = (_c = ctx.reporter).onWatcherStart) === null || _d === void 0 ? void 0 : _d.call(_c, ctx));
+        }, 100);
+    });
+}
+function getDependencyTests(id, ctx, set = new Set(), seen = new Set()) {
+    if (seen.has(id) || set.has(id))
+        return set;
+    seen.add(id);
+    if (id in ctx.filesMap) {
+        set.add(id);
+        return set;
+    }
+    const mod = process.__vite_node__.server.moduleGraph.getModuleById(id);
+    if (mod) {
+        mod.importers.forEach((i) => {
+            if (i.id)
+                getDependencyTests(i.id, ctx, set, seen);
+        });
+    }
+    return set;
 }

package/dist/types.d.ts

@@ -1,4 +1,3 @@
-import { ViteDevServer } from 'vite';
 export declare type Awaitable<T> = Promise<T> | T;
 export interface UserOptions {
     includes?: string[];
@@ -21,13 +20,22 @@ export interface UserOptions {
      * @default false
      */
     parallel?: boolean;
-}
-export interface Config extends UserOptions {
-    rootDir?: string;
-    updateSnapshot?: boolean;
-    nameFilters?: string[];
-    server: ViteDevServer;
+    /**
+     * Update snapshot files
+     *
+     * @default false
+     */
+    update?: boolean;
+    /**
+     * Watch mode
+     *
+     * @default false
+     */
     watch?: boolean;
+    root?: string;
+}
+export interface ResolvedConfig extends Required<UserOptions> {
+    filters?: string[];
 }
 export declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
 export declare type TaskState = RunMode | 'pass' | 'fail';
@@ -78,8 +86,11 @@ export interface File {
     error?: unknown;
 }
 export interface RunnerContext {
+    filesMap: Record<string, File>;
     files: File[];
-    config: Config;
+    suites: Suite[];
+    tasks: Task[];
+    config: ResolvedConfig;
     reporter: Reporter;
 }
 export interface GlobalContext {
@@ -87,8 +98,8 @@ export interface GlobalContext {
     currentSuite: SuiteCollector | null;
 }
 export interface Reporter {
-    onStart?: (userOptions: Config) => Awaitable<void>;
-    onCollected?: (ctx: RunnerContext) => Awaitable<void>;
+    onStart?: (userOptions: ResolvedConfig) => Awaitable<void>;
+    onCollected?: (files: File[], ctx: RunnerContext) => Awaitable<void>;
     onFinished?: (ctx: RunnerContext) => Awaitable<void>;
     onSuiteBegin?: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;
     onSuiteEnd?: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;
@@ -96,5 +107,7 @@ export interface Reporter {
     onFileEnd?: (file: File, ctx: RunnerContext) => Awaitable<void>;
     onTaskBegin?: (task: Task, ctx: RunnerContext) => Awaitable<void>;
     onTaskEnd?: (task: Task, ctx: RunnerContext) => Awaitable<void>;
+    onWatcherStart?: (ctx: RunnerContext) => Awaitable<void>;
+    onWatcherRerun?: (files: string[], trigger: string, ctx: RunnerContext) => Awaitable<void>;
     onSnapshotUpdate?: () => Awaitable<void>;
 }

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "vitest",
-  "version": "0.0.19",
-  "description": "",
-  "keywords": [],
+  "version": "0.0.23",
+  "description": "A blazing fast unit test framework powered by Vite",
+  "keywords": [
+    "vite",
+    "vite-node",
+    "test",
+    "jest"
+  ],
   "homepage": "https://github.com/antfu/vitest#readme",
   "bugs": {
     "url": "https://github.com/antfu/vitest/issues"
@@ -44,9 +49,8 @@
     "jest-util": "^27.4.2",
     "jsdom": "^19.0.0",
     "listr": "^0.14.3",
-    "minimist": "^1.2.5",
-    "ora": "^6.0.1",
     "picocolors": "^1.0.0",
+    "sade": "^1.7.4",
     "sinon": "^12.0.1",
     "sinon-chai": "^3.7.0"
   },
@@ -55,8 +59,8 @@
     "@antfu/ni": "^0.11.0",
     "@types/jsdom": "^16.2.13",
     "@types/listr": "^0.14.4",
-    "@types/minimist": "^1.2.2",
     "@types/node": "^16.11.11",
+    "@types/sade": "^1.7.3",
     "@types/sinon": "^10.0.6",
     "bumpp": "^7.1.1",
     "eslint": "^8.3.0",

package/dist/node.d.ts

@@ -1,11 +0,0 @@
-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/run.d.ts

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