vitest 0.0.29 → 0.0.33

package/README.gh.md

@@ -11,17 +11,21 @@ A blazing fast unit test framework powered by Vite.
 
 > Vitest requires Vite v2.7.0 or above
 
+[**Join the Discord!**](https://discord.com/invite/2zYZNngd7y)
+
 ## Features
 
 - [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
+- [Chai](https://www.chaijs.com/) built-in for assertions, with [jest-expect](https://jestjs.io/docs/expect) compatible APIs.
+- [Sinon](https://sinonjs.org/) built-in for mocking
+- [JSDOM](https://github.com/jsdom/jsdom) built-in built-in for DOM mocking
+- Components testing ([Vue example](./test/vue), [React example](./test/react))
 - Async suite / test, top level await
 - ESM friendly
-- Out-of-box TypeScript support
+- Out-of-box TypeScript / JSX support
 - Suite and Test filtering (skip, only, todo)
+- [Test coverage](#coverage)
 
 ```ts
 import { it, describe, expect, assert } from 'vitest'
@@ -46,6 +50,12 @@ describe('suite name', () => {
 $ npx vitest
 ```
 
+## Examples
+
+- [Unit Testing](./test/core)
+- [Vue Component Testing](./test/vue)
+- [React Component Testing](./test/react)
+
 ## 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:
@@ -84,7 +94,7 @@ export default defineConfig({
 
 To get TypeScript working with the global APIs, add `vitest/global` to the `types` filed in your `tsconfig.json`
 
-```json
+```jsonc
 // tsconfig.json
 {
   "compilerOptions": {
@@ -118,6 +128,31 @@ $ vitest -w
 
 Vitest smartly searches the module graph and only rerun the related tests (just like how HMR works in Vite!).
 
+## Coverage
+
+Vitest works perfectly with [c8](https://github.com/bcoe/c8)
+
+```bash
+$ c8 vitest
+```
+
+```json
+{
+  "scripts": {
+    "test": "vitest",
+    "coverage": "c8 vitest"
+  }
+}
+```
+
+For convenience, we also provide a shorthand for passing `--coverage` option to CLI, which will wrap the process with `c8` for you. Note when using the shorthand, you will lose the ability to pass additional options to `c8`.
+
+```bash
+$ vitest --coverage
+```
+
+For more configuration avaliable, please refer to [c8](https://github.com/bcoe/c8)'s documentation.
+
 ## Filtering
 
 ### CLI
@@ -194,19 +229,6 @@ describe('suite', () => {
 })
 ```
 
-## TODO
-
-- [x] Reporter & Better output
-- [x] Task filter
-- [x] Mock
-- [x] Global Mode & Types
-- [ ] Parallel Executing
-- [x] CLI Help
-- [x] JSDom
-- [x] Watch
-- [ ] Source Map
-- [ ] Coverage
-
 ## Sponsors
 
 <p align="center">

package/bin/vitest.mjs

@@ -1,4 +1,16 @@
 #!/usr/bin/env node
-'use strict'
 
-import '../dist/node/cli.js'
+import { fileURLToPath } from 'url'
+import { resolve } from 'path'
+
+const argv = process.argv.slice(2)
+const filename = fileURLToPath(import.meta.url)
+const entry = resolve(filename, '../../dist/node/cli.js')
+
+if (argv.includes('--coverage')) {
+  process.argv.splice(2, 0, process.argv[0], entry)
+  await import('c8/bin/c8.js')
+}
+else {
+  await import('../dist/node/cli.js')
+}

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

@@ -24,6 +24,7 @@ export declare class SnapshotManager {
     setTask(task: Task): void;
     setContext(context: Context): void;
     assert(received: unknown, message: string): void;
+    clear(): void;
     saveSnap(): void;
-    report(): void;
+    report(): string[] | undefined;
 }

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

@@ -58,6 +58,9 @@ export class SnapshotManager {
             expect(actual.trim()).equals(expected ? expected.trim() : '', message || `Snapshot name: \`${key}\``);
         }
     }
+    clear() {
+        this.snapshotSummary = makeEmptySnapshotSummary(this.snapshotOptions);
+    }
     saveSnap() {
         if (!this.testFile || !this.snapshotState)
             return;
@@ -69,7 +72,6 @@ export class SnapshotManager {
     report() {
         const outputs = getSnapshotSummaryOutput(this.rootDir, this.snapshotSummary);
         if (outputs.length > 1)
-            // eslint-disable-next-line no-console
-            console.log(`\n${outputs.join('\n')}`);
+            return outputs;
     }
 }

package/dist/node/cli.js

@@ -24,6 +24,7 @@ sade('vitest [filter]', true)
     const defaultInline = [
         'vue',
         '@vue',
+        'diff',
     ];
     const __dirname = dirname(fileURLToPath(import.meta.url));
     const root = resolve(argv.root || process.cwd());

package/dist/node/entry.js

@@ -5,3 +5,8 @@ const inlineOptions = process.__vite_node__.server.config.test || {};
 const cliOptions = process.__vitest__.options || {};
 const options = Object.assign(Object.assign({}, cliOptions), inlineOptions);
 await run(options);
+const timer = setTimeout(() => {
+    // TODO: warn user and maybe error out
+    process.exit();
+}, 500);
+timer.unref();

package/dist/node/node.d.ts

@@ -1,4 +1,4 @@
-import { InlineConfig, ViteDevServer } from 'vite';
+import { InlineConfig, ViteDevServer, TransformResult } from 'vite';
 declare global {
     namespace NodeJS {
         interface Process {
@@ -6,6 +6,7 @@ declare global {
                 server: ViteDevServer;
                 watch?: boolean;
                 moduleCache: Map<string, Promise<any>>;
+                modulesTransformResult: Map<string, TransformResult>;
             };
         }
     }

package/dist/node/node.js

@@ -5,7 +5,8 @@ import vm from 'vm';
 import { createServer, mergeConfig } from 'vite';
 import c from 'picocolors';
 const { red, dim, yellow } = c;
-const __pendingModules__ = new Map();
+const moduleCache = new Map();
+const modulesTransformResult = new Map();
 export async function run(argv) {
     process.exitCode = 0;
     const root = argv.root || process.cwd();
@@ -22,7 +23,8 @@ export async function run(argv) {
     await server.pluginContainer.buildStart({});
     process.__vite_node__ = {
         server,
-        moduleCache: __pendingModules__,
+        moduleCache,
+        modulesTransformResult,
     };
     try {
         await execute(files, server, argv);
@@ -104,6 +106,7 @@ async function execute(files, server, options) {
         const result = await transform(server, id);
         if (!result)
             throw new Error(`failed to load ${id}`);
+        modulesTransformResult.set(id, result);
         const url = pathToFileURL(fsPath);
         const exports = {};
         const context = {
@@ -130,10 +133,10 @@ async function execute(files, server, options) {
         const fsPath = toFilePath(id, server);
         if (options.shouldExternalize(fsPath, server))
             return import(fsPath);
-        if (__pendingModules__.has(fsPath))
-            return __pendingModules__.get(fsPath);
-        __pendingModules__.set(fsPath, directRequest(id, fsPath, callstack));
-        return await __pendingModules__.get(fsPath);
+        if (moduleCache.has(fsPath))
+            return moduleCache.get(fsPath);
+        moduleCache.set(fsPath, directRequest(id, fsPath, callstack));
+        return await moduleCache.get(fsPath);
     }
     function exportAll(exports, sourceModule) {
         // eslint-disable-next-line no-restricted-syntax

package/dist/reporters/default.d.ts

@@ -16,7 +16,7 @@ export declare class DefaultReporter implements Reporter {
     onStart(config: ResolvedConfig): void;
     onCollected(files: File[]): void;
     onTaskEnd(task: Task): void;
-    onFinished(ctx: RunnerContext): Promise<void>;
+    onFinished(ctx: RunnerContext, files?: File[]): Promise<void>;
     onWatcherStart(ctx: RunnerContext): Promise<void>;
     onWatcherRerun(files: string[], trigger: string): Promise<void>;
     onSnapshotUpdate(): void;

package/dist/reporters/default.js

@@ -3,6 +3,7 @@ import { performance } from 'perf_hooks';
 import { relative } from 'path';
 import c from 'picocolors';
 import Listr from 'listr';
+import { printError } from './error';
 const CROSS = '✖ ';
 export class DefaultReporter {
     constructor() {
@@ -77,11 +78,16 @@ export class DefaultReporter {
         else
             (_b = this.taskMap.get(task)) === null || _b === void 0 ? void 0 : _b.resolve();
     }
-    async onFinished(ctx) {
+    async onFinished(ctx, files = ctx.files) {
+        var _a;
         await this.listrPromise;
         this.end = performance.now();
         console.log();
-        const { tasks, suites, files } = ctx;
+        const snapshot = ctx.snapshotManager.report();
+        if (snapshot)
+            console.log(snapshot.join('\n'));
+        const suites = files.flatMap(i => i.suites);
+        const tasks = suites.flatMap(i => i.tasks);
         const failedFiles = files.filter(i => i.error);
         const failedSuites = suites.filter(i => i.error);
         const runnable = tasks.filter(i => i.state === 'pass' || i.state === 'fail');
@@ -90,30 +96,30 @@ export class DefaultReporter {
         const skipped = tasks.filter(i => i.state === 'skip');
         const todo = tasks.filter(i => i.state === 'todo');
         if (failedFiles.length) {
-            console.error(c.bold(`\nFailed to parse ${failedFiles.length} files:`));
-            failedFiles.forEach((i) => {
-                console.error(c.red(`\n- ${i.filepath}`));
-                console.error(i.error || 'Unknown error');
+            console.error(c.red(c.bold(`\nFailed to parse ${failedFiles.length} files:`)));
+            for (const file of failedFiles)
+                console.error(c.red(`- ${file.filepath}`));
+            console.log();
+            for (const file of failedFiles) {
+                await printError(file.error);
                 console.log();
-            });
+            }
         }
         if (failedSuites.length) {
             console.error(c.bold(c.red(`\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');
+            for (const suite of failedSuites) {
+                console.error(c.red(`\n- ${(_a = suite.file) === null || _a === void 0 ? void 0 : _a.filepath} > ${suite.name}`));
+                await printError(suite.error);
                 console.log();
-            });
+            }
         }
         if (failed.length) {
             console.error(c.bold(c.red(`\nFailed Tests (${failed.length})`)));
-            failed.forEach((task) => {
-                var _a;
-                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');
+            for (const task of failed) {
+                console.error(`${c.red(`\n${CROSS + c.inverse(' FAIL ')}`)} ${[task.suite.name, task.name].filter(Boolean).join(' > ')}`);
+                await printError(task.error);
                 console.log();
-            });
+            }
         }
         console.log(c.bold(c.green(`Passed   ${passed.length} / ${runnable.length}`)));
         if (failed.length)

package/dist/reporters/error.d.ts

@@ -0,0 +1,9 @@
+export declare function printError(error: unknown): Promise<void>;
+interface Poisition {
+    line: number;
+    column: number;
+}
+export declare function posToNumber(source: string, pos: number | Poisition): number;
+export declare function numberToPos(source: string, offset: number | Poisition): Poisition;
+export declare function generateCodeFrame(source: string, start?: number | Poisition, end?: number, range?: number): string;
+export {};

package/dist/reporters/error.js

@@ -0,0 +1,182 @@
+/* eslint-disable no-console */
+import { promises as fs, existsSync } from 'fs';
+import c from 'picocolors';
+import * as diff from 'diff';
+import { notNullish } from '@antfu/utils';
+import { SourceMapConsumer } from 'source-map';
+export async function printError(error) {
+    if (!(error instanceof Error)) {
+        console.error(error);
+        return;
+    }
+    const { modulesTransformResult } = process.__vite_node__;
+    const e = error;
+    let codeFramePrinted = false;
+    const stacks = parseStack(e.stack || '');
+    const nearest = stacks.find(stack => modulesTransformResult.has(stack.file));
+    if (nearest) {
+        const transformResult = modulesTransformResult.get(nearest.file);
+        const pos = await getOriginalPos(transformResult === null || transformResult === void 0 ? void 0 : transformResult.map, nearest);
+        if (pos && existsSync(nearest.file)) {
+            const sourceCode = await fs.readFile(nearest.file, 'utf-8');
+            console.error(`${c.red(`${c.bold(e.name)}: ${e.message}`)}`);
+            console.log(c.gray(`${nearest.file}:${pos.line}:${pos.column}`));
+            console.log(c.yellow(generateCodeFrame(sourceCode, pos)));
+            codeFramePrinted = true;
+        }
+    }
+    if (!codeFramePrinted)
+        console.error(e);
+    if (e.showDiff)
+        console.error(c.gray(generateDiff(stringify(e.actual), stringify(e.expected))));
+}
+function getOriginalPos(map, { line, column }) {
+    return new Promise((resolve) => {
+        if (!map)
+            return resolve(null);
+        SourceMapConsumer.with(map, null, (consumer) => {
+            const pos = consumer.originalPositionFor({ line, column });
+            if (pos.line != null && pos.column != null)
+                resolve(pos);
+            else
+                resolve(null);
+        });
+    });
+}
+const splitRE = /\r?\n/;
+export function posToNumber(source, pos) {
+    if (typeof pos === 'number')
+        return pos;
+    const lines = source.split(splitRE);
+    const { line, column } = pos;
+    let start = 0;
+    for (let i = 0; i < line - 1; i++)
+        start += lines[i].length + 1;
+    return start + column;
+}
+export function numberToPos(source, offset) {
+    if (typeof offset !== 'number')
+        return offset;
+    if (offset > source.length) {
+        throw new Error(`offset is longer than source length! offset ${offset} > length ${source.length}`);
+    }
+    const lines = source.split(splitRE);
+    let counted = 0;
+    let line = 0;
+    let column = 0;
+    for (; line < lines.length; line++) {
+        const lineLength = lines[line].length + 1;
+        if (counted + lineLength >= offset) {
+            column = offset - counted + 1;
+            break;
+        }
+        counted += lineLength;
+    }
+    return { line: line + 1, column };
+}
+export function generateCodeFrame(source, start = 0, end, range = 2) {
+    start = posToNumber(source, start);
+    end = end || start;
+    const lines = source.split(splitRE);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${c.gray(`${line}${' '.repeat(Math.max(3 - String(line).length, 0))}|`)}  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`${c.gray('   |')}  ${' '.repeat(pad)}${'^'.repeat(length)}`);
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`${c.gray('   |')}  ${'^'.repeat(length)}`);
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+function stringify(obj) {
+    // TODO: handle more types
+    return String(obj);
+}
+const stackFnCallRE = /at (.*) \((.+):(\d+):(\d+)\)$/;
+const stackBarePathRE = /at ()(.+):(\d+):(\d+)$/;
+function parseStack(stack) {
+    const lines = stack.split('\n');
+    const stackFrames = lines.map((raw) => {
+        const line = raw.trim();
+        const match = line.match(stackFnCallRE) || line.match(stackBarePathRE);
+        if (!match)
+            return null;
+        let file = match[2];
+        if (file.startsWith('file://'))
+            file = file.slice(7);
+        return {
+            method: match[1],
+            file: match[2],
+            line: parseInt(match[3]),
+            column: parseInt(match[4]),
+        };
+    });
+    return stackFrames.filter(notNullish);
+}
+/**
+ * Returns a diff between 2 strings with coloured ANSI output.
+ *
+ * @description
+ * The diff will be either inline or unified dependent on the value
+ * of `Base.inlineDiff`.
+ *
+ * @param {string} actual
+ * @param {string} expected
+ * @return {string} Diff
+ */
+function generateDiff(actual, expected) {
+    const diffSize = 2048;
+    if (actual.length > diffSize)
+        actual = `${actual.substring(0, diffSize)} ... Lines skipped`;
+    if (expected.length > diffSize)
+        expected = `${expected.substring(0, diffSize)} ... Lines skipped`;
+    return unifiedDiff(actual, expected);
+}
+/**
+ * Returns unified diff between two strings with coloured ANSI output.
+ *
+ * @private
+ * @param {String} actual
+ * @param {String} expected
+ * @return {string} The diff.
+ */
+function unifiedDiff(actual, expected) {
+    const indent = '  ';
+    function cleanUp(line) {
+        if (line[0] === '+')
+            return indent + c.green(`${line[0]} ${line.slice(1)}`);
+        if (line[0] === '-')
+            return indent + c.red(`${line[0]} ${line.slice(1)}`);
+        if (line.match(/@@/))
+            return '--';
+        if (line.match(/\\ No newline/))
+            return null;
+        return indent + line;
+    }
+    const msg = diff.createPatch('string', actual, expected);
+    const lines = msg.split('\n').splice(5);
+    return (`\n${indent}${c.red('- actual')}\n${indent}${c.green('+ expected')}\n\n${lines.map(cleanUp).filter(notBlank).join('\n')}`);
+}
+function notBlank(line) {
+    return typeof line !== 'undefined' && line !== null;
+}

package/dist/run/index.js

@@ -163,6 +163,7 @@ export async function run(config) {
         (await import('../integrations/jsdom')).setupJSDOM(globalThis);
     await ((_b = reporter.onStart) === null || _b === void 0 ? void 0 : _b.call(reporter, config));
     const filesMap = await collectFiles(testFilepaths);
+    const snapshotManager = getSnapshotManager();
     const ctx = {
         filesMap,
         get files() {
@@ -177,24 +178,25 @@ export async function run(config) {
                 .reduce((tasks, suite) => tasks.concat(suite.tasks), []);
         },
         config,
-        reporter: config.reporter,
+        reporter,
+        snapshotManager,
     };
     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();
+    snapshotManager.saveSnap();
     await ((_c = reporter.onFinished) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
     if (config.watch)
-        startWatcher(ctx);
+        await 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));
+    var _a;
+    const { reporter, snapshotManager, filesMap } = ctx;
+    await ((_a = reporter.onWatcherStart) === null || _a === void 0 ? void 0 : _a.call(reporter, ctx));
     let timer;
     const changedTests = new Set();
     const seen = new Set();
     const { server, moduleCache } = process.__vite_node__;
     server.watcher.on('change', async (id) => {
+        id = normalizePath(id);
         getDependencyTests(id, ctx, changedTests, seen);
         seen.forEach(i => moduleCache.delete(i));
         seen.clear();
@@ -202,23 +204,30 @@ export async function startWatcher(ctx) {
             return;
         clearTimeout(timer);
         timer = setTimeout(async () => {
-            var _a, _b, _c, _d;
+            var _a, _b, _c;
             if (changedTests.size === 0)
                 return;
-            const snapshot = getSnapshotManager();
+            snapshotManager.clear();
             const paths = Array.from(changedTests);
             changedTests.clear();
-            await ((_b = (_a = ctx.reporter).onWatcherRerun) === null || _b === void 0 ? void 0 : _b.call(_a, paths, id, ctx));
+            await ((_a = reporter.onWatcherRerun) === null || _a === void 0 ? void 0 : _a.call(reporter, paths, id, ctx));
             paths.forEach(i => moduleCache.delete(i));
-            const files = await collectFiles(paths);
-            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));
+            const newFilesMap = await collectFiles(paths);
+            Object.assign(filesMap, newFilesMap);
+            await runFiles(newFilesMap, ctx);
+            snapshotManager.saveSnap();
+            await ((_b = reporter.onFinished) === null || _b === void 0 ? void 0 : _b.call(reporter, ctx, Object.values(newFilesMap)));
+            await ((_c = reporter.onWatcherStart) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
         }, 100);
     });
+    // add an empty promise so it never resolves
+    await new Promise(() => { });
+}
+function normalizePath(path) {
+    const normalized = path.replace(/\\/g, '/');
+    if (normalized.startsWith('/'))
+        return normalized;
+    return `/${normalized}`;
 }
 function getDependencyTests(id, ctx, set = new Set(), seen = new Set()) {
     if (seen.has(id) || set.has(id))

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import { SnapshotManager } from './integrations/chai/snapshot/manager';
 export declare type Awaitable<T> = Promise<T> | T;
 export interface UserOptions {
     /**
@@ -116,6 +117,7 @@ export interface RunnerContext {
     tasks: Task[];
     config: ResolvedConfig;
     reporter: Reporter;
+    snapshotManager: SnapshotManager;
 }
 export interface GlobalContext {
     suites: SuiteCollector[];
@@ -124,7 +126,7 @@ export interface GlobalContext {
 export interface Reporter {
     onStart?: (config: ResolvedConfig) => Awaitable<void>;
     onCollected?: (files: File[], ctx: RunnerContext) => Awaitable<void>;
-    onFinished?: (ctx: RunnerContext) => Awaitable<void>;
+    onFinished?: (ctx: RunnerContext, files?: File[]) => Awaitable<void>;
     onSuiteBegin?: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;
     onSuiteEnd?: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;
     onFileBegin?: (file: File, ctx: RunnerContext) => Awaitable<void>;
@@ -133,5 +135,4 @@ export interface Reporter {
     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,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.29",
+  "version": "0.0.33",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",
@@ -47,14 +47,19 @@
     "test": "run-s test:*",
     "test:core": "node bin/vitest.mjs --dev -r test/core",
     "test:vue": "node bin/vitest.mjs --dev -r test/vue",
+    "test:react": "node bin/vitest.mjs --dev -r test/react",
+    "coverage": "node bin/vitest.mjs --dev -r test/core --coverage",
     "watch": "tsc -p src/tsconfig.json --watch"
   },
   "dependencies": {
+    "@antfu/utils": "^0.3.0",
     "@jest/test-result": "^27.4.2",
     "@types/chai": "^4.2.22",
     "@types/sinon-chai": "^3.2.6",
+    "c8": "^7.10.0",
     "chai": "^4.3.4",
     "chai-subset": "^1.6.0",
+    "diff": "^5.0.0",
     "fast-glob": "^3.2.7",
     "find-up": "^6.2.0",
     "jest-snapshot": "^27.4.2",
@@ -64,28 +69,28 @@
     "picocolors": "^1.0.0",
     "sade": "^1.7.4",
     "sinon": "^12.0.1",
-    "sinon-chai": "^3.7.0"
+    "sinon-chai": "^3.7.0",
+    "source-map": "^0.7.3"
   },
   "peerDependencies": {
-    "vite": "^2.7.0"
+    "vite": "^2.7.1"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^0.12.1",
+    "@antfu/eslint-config": "^0.12.2",
     "@antfu/ni": "^0.11.0",
     "@types/chai-subset": "^1.3.3",
+    "@types/diff": "^5.0.1",
     "@types/jsdom": "^16.2.13",
     "@types/listr": "^0.14.4",
-    "@types/node": "^16.11.11",
+    "@types/node": "^16.11.12",
     "@types/sade": "^1.7.3",
     "@types/sinon": "^10.0.6",
-    "@vitejs/plugin-vue": "^1.10.1",
     "bumpp": "^7.1.1",
-    "eslint": "^8.4.0",
+    "eslint": "^8.4.1",
     "esno": "^0.12.1",
     "npm-run-all": "^4.1.5",
     "rimraf": "^3.0.2",
     "typescript": "^4.5.2",
-    "vite": "^2.7.0",
-    "vue": "^3.2.24"
+    "vite": "^2.7.1"
   }
 }