npm - vitest - Versions diffs - 0.0.18 → 0.0.22 - Mend

vitest 0.0.18 → 0.0.22

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

package/README.md +3 -3
package/dist/cli.js +3 -3
package/dist/entry.js +1 -1
package/dist/index.d.ts +1 -0
package/dist/integrations/chai/jest-expect.js +4 -1
package/dist/integrations/{jsdom.d.ts → jsdom/index.d.ts} +0 -0
package/dist/integrations/{jsdom.js → jsdom/index.js} +2 -1
package/dist/integrations/jsdom/keys.d.ts +1 -0
package/dist/integrations/jsdom/keys.js +220 -0
package/dist/node/index.d.ts +22 -0
package/dist/{node.js → node/index.js} +24 -21
package/dist/reporters/default.d.ts +5 -8
package/dist/reporters/default.js +39 -31
package/dist/run/index.d.ts +8 -0
package/dist/run/index.js +236 -0
package/dist/types.d.ts +14 -1
package/package.json +1 -1
package/dist/node.d.ts +0 -11
package/dist/run.d.ts +0 -5
package/dist/run.js +0 -134

package/README.md CHANGED Viewed

@@ -156,9 +156,9 @@ describe('suite', () => {
 - [x] Mock
 - [x] Global Mode & Types
 - [ ] Parallel Executing
-- [ ] CLI Help
-- [ ] JSDom
-- [ ] Watch
+- [ ] CLI Help (Use yargs)
+- [x] JSDom
+- [x] Watch
 - [ ] Source Map
 - [ ] Coverage

package/dist/cli.js CHANGED Viewed

@@ -1,4 +1,3 @@
-var _a;
 import minimist from 'minimist';
 import c from 'picocolors';
 import { run } from './run';
@@ -19,8 +18,9 @@ const argv = minimist(process.argv.slice(2), {
         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;
+if (!process.__vite_node__)
+    throw new Error('Vite can only run in Vite environment, please use the CLI to start the process');
+const server = process.__vite_node__.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._ }));

package/dist/entry.js CHANGED Viewed

@@ -2,7 +2,7 @@ import { fileURLToPath } from 'url';
 import { resolve, dirname } from 'path';
 import minimist from 'minimist';
 import { findUp } from 'find-up';
-import { run } from './node.js';
+import { run } from './node/index.js';
 process.env.VITEST = 'true';
 const argv = minimist(process.argv.slice(2), {
     alias: {

package/dist/index.d.ts CHANGED Viewed

@@ -22,6 +22,7 @@ declare global {
             toBeCalledTimes(n: number): void;
             toBeCalledOnce(): void;
             toBeCalled(): void;
+            toHaveBeenCalled(): void;
         }
         interface ExpectStatic {
             addSnapshotSerializer: import('pretty-format').Plugin;

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

@@ -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);
         });
@@ -48,5 +48,8 @@ export function JestChaiExpect() {
         utils.addMethod(proto, 'toBeCalled', function () {
             return this.called;
         });
+        utils.addMethod(proto, 'toHaveBeenCalled', function () {
+            return this.called;
+        });
     };
 }

package/dist/integrations/{jsdom.d.ts → jsdom/index.d.ts} RENAMED Viewed

File without changes

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

@@ -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 ADDED Viewed

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

package/dist/integrations/jsdom/keys.js ADDED Viewed

@@ -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 ADDED Viewed

@@ -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} RENAMED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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,55 +64,66 @@ 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();
+        console.log();
+        const { tasks, suites, files } = ctx;
         const failedFiles = files.filter(i => i.error);
-        const tasks = files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
+        const failedSuites = suites.filter(i => i.error);
         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:`));
+            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) {
+            console.error(c.bold(`\nFailed to run ${failedSuites.length} suites:`));
+            failedSuites.forEach((i) => {
+                var _a;
+                console.error(c.red(`\n- ${(_a = i.file) === null || _a === void 0 ? void 0 : _a.filepath} > ${i.name}`));
+                console.error(i.error || 'Unknown error');
+                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 ADDED Viewed

@@ -0,0 +1,8 @@
+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<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: Config): Promise<void>;
+export declare function startWatcher(ctx: RunnerContext): Promise<void>;

package/dist/run/index.js ADDED Viewed

@@ -0,0 +1,236 @@
+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';
+async function callHook(suite, name, args) {
+    await Promise.all(suite.hooks[name].map(fn => fn(...args)));
+}
+export async function runTask(task, ctx) {
+    var _a, _b, _c;
+    const { reporter } = ctx;
+    (_a = getSnapshotManager()) === null || _a === void 0 ? void 0 : _a.setTask(task);
+    await ((_b = reporter.onTaskBegin) === null || _b === void 0 ? void 0 : _b.call(reporter, task, ctx));
+    if (task.mode === 'run') {
+        try {
+            await callHook(task.suite, 'beforeEach', [task, task.suite]);
+            await task.fn();
+            task.state = 'pass';
+        }
+        catch (e) {
+            task.state = 'fail';
+            task.error = e;
+            process.exitCode = 1;
+        }
+        try {
+            await callHook(task.suite, 'afterEach', [task, task.suite]);
+        }
+        catch (e) {
+            task.state = 'fail';
+            task.error = e;
+            process.exitCode = 1;
+        }
+    }
+    await ((_c = reporter.onTaskEnd) === null || _c === void 0 ? void 0 : _c.call(reporter, task, ctx));
+}
+export async function collectFiles(paths) {
+    const files = {};
+    for (const filepath of paths) {
+        const file = {
+            filepath,
+            suites: [],
+            collected: false,
+        };
+        clearContext();
+        try {
+            await import(filepath);
+            const collectors = [defaultSuite, ...context.suites];
+            for (const c of collectors) {
+                context.currentSuite = c;
+                file.suites.push(await c.collect(file));
+            }
+            file.collected = true;
+        }
+        catch (e) {
+            file.error = e;
+            file.collected = false;
+            process.exitCode = 1;
+        }
+        files[filepath] = file;
+    }
+    const allFiles = Object.values(files);
+    const allSuites = allFiles.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';
+        });
+    }
+}
+export async function runSite(suite, ctx) {
+    var _a, _b;
+    const { reporter } = ctx;
+    await ((_a = reporter.onSuiteBegin) === null || _a === void 0 ? void 0 : _a.call(reporter, suite, ctx));
+    if (suite.mode === 'skip') {
+        suite.status = 'skip';
+    }
+    else if (suite.mode === 'todo') {
+        suite.status = 'todo';
+    }
+    else {
+        try {
+            await callHook(suite, 'beforeAll', [suite]);
+            await Promise.all(suite.tasks.map(i => runTask(i, ctx)));
+            // for (const t of suite.tasks)
+            //   await runTask(t, ctx)
+            await callHook(suite, 'afterAll', [suite]);
+        }
+        catch (e) {
+            suite.error = e;
+            suite.status = 'fail';
+            process.exitCode = 1;
+        }
+    }
+    await ((_b = reporter.onSuiteEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, suite, ctx));
+}
+export async function runFile(file, ctx) {
+    var _a, _b;
+    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));
+    if (ctx.config.parallel) {
+        await Promise.all(file.suites.map(suite => runSite(suite, ctx)));
+    }
+    else {
+        for (const suite of file.suites)
+            await runSite(suite, 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;
+    // 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 testFilepaths = await fg(config.includes || defaultIncludes, {
+        absolute: true,
+        cwd: config.rootDir,
+        ignore: config.excludes || defaultExcludes,
+    });
+    // if name filters are provided by the CLI
+    if ((_a = config.nameFilters) === null || _a === void 0 ? void 0 : _a.length)
+        testFilepaths = testFilepaths.filter(i => config.nameFilters.some(f => i.includes(f)));
+    if (!testFilepaths.length) {
+        console.error('No test files found');
+        process.exitCode = 1;
+        return;
+    }
+    // setup envs
+    if (config.global)
+        (await import('../global')).registerApiGlobally();
+    if (config.jsdom)
+        (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 = {
+        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 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 ((_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 CHANGED Viewed

@@ -15,6 +15,12 @@ export interface UserOptions {
      * @default false
      */
     jsdom?: boolean;
+    /**
+     * Run tests files in parallel
+     *
+     * @default false
+     */
+    parallel?: boolean;
 }
 export interface Config extends UserOptions {
     rootDir?: string;
@@ -47,6 +53,8 @@ export interface Suite {
     mode: RunMode;
     tasks: Task[];
     file?: File;
+    error?: unknown;
+    status?: TaskState;
     hooks: {
         beforeAll: HookListener<[Suite]>[];
         afterAll: HookListener<[Suite]>[];
@@ -70,7 +78,10 @@ export interface File {
     error?: unknown;
 }
 export interface RunnerContext {
+    filesMap: Record<string, File>;
     files: File[];
+    suites: Suite[];
+    tasks: Task[];
     config: Config;
     reporter: Reporter;
 }
@@ -80,7 +91,7 @@ export interface GlobalContext {
 }
 export interface Reporter {
     onStart?: (userOptions: Config) => Awaitable<void>;
-    onCollected?: (ctx: RunnerContext) => 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>;
@@ -88,5 +99,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 CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.18",
+  "version": "0.0.22",
   "description": "",
   "keywords": [],
   "homepage": "https://github.com/antfu/vitest#readme",

package/dist/node.d.ts DELETED Viewed

@@ -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 DELETED Viewed

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

package/dist/run.js DELETED Viewed

@@ -1,134 +0,0 @@
-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';
-async function callHook(suite, name, args) {
-    await Promise.all(suite.hooks[name].map(fn => fn(...args)));
-}
-export async function runTask(task, ctx) {
-    var _a, _b, _c;
-    const { reporter } = ctx;
-    (_a = getSnapshotManager()) === null || _a === void 0 ? void 0 : _a.setTask(task);
-    await ((_b = reporter.onTaskBegin) === null || _b === void 0 ? void 0 : _b.call(reporter, task, ctx));
-    if (task.mode === 'run') {
-        await callHook(task.suite, 'afterEach', [task, task.suite]);
-        try {
-            await task.fn();
-            task.state = 'pass';
-        }
-        catch (e) {
-            task.state = 'fail';
-            task.error = e;
-        }
-        await callHook(task.suite, 'afterEach', [task, task.suite]);
-    }
-    await ((_c = reporter.onTaskEnd) === null || _c === void 0 ? void 0 : _c.call(reporter, task, ctx));
-}
-export async function collectFiles(paths) {
-    const files = [];
-    for (const filepath of paths) {
-        const file = {
-            filepath,
-            suites: [],
-            collected: false,
-        };
-        clearContext();
-        try {
-            await import(filepath);
-            const collectors = [defaultSuite, ...context.suites];
-            for (const c of collectors) {
-                context.currentSuite = c;
-                file.suites.push(await c.collect(file));
-            }
-            file.collected = true;
-        }
-        catch (e) {
-            file.error = e;
-            file.collected = false;
-            process.exitCode = 1;
-        }
-        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';
-        });
-    }
-}
-export async function runFile(file, ctx) {
-    var _a, _b;
-    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));
-    // TODO: support toggling parallel or serial
-    await Promise.all(file.suites.map(async (suite) => {
-        var _a, _b;
-        await ((_a = reporter.onSuiteBegin) === null || _a === void 0 ? void 0 : _a.call(reporter, suite, ctx));
-        await callHook(suite, 'beforeAll', [suite]);
-        await Promise.all(suite.tasks.map(i => runTask(i, ctx)));
-        // for (const t of suite.tasks)
-        //   await runTask(t, ctx)
-        await callHook(suite, 'afterAll', [suite]);
-        await ((_b = reporter.onSuiteEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, suite, ctx));
-    }));
-    await ((_b = reporter.onFileEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, file, ctx));
-}
-export async function run(config) {
-    var _a, _b, _c, _d;
-    // setup chai
-    await setupChai(config);
-    // collect files
-    let paths = await fg(config.includes || defaultIncludes, {
-        absolute: true,
-        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 ((_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,
-        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);
-    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));
-}