vitest 0.0.0 → 0.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,57 @@
+# vitest
+
+[![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.
+
+## Features
+
+- Vite's transformer, resolver, and plugin system. Powered by [vite-node](https://github.com/antfu/vite-node).
+- Jest Snapshot.
+- Chai for assertions.
+- Async suite / test.
+- ESM friendly, top level await.
+
+```ts
+import { it, describe, expect, assert } from 'vitest'
+
+describe('suite name', () => {
+  it('foo', () => {
+    assert.equal(Math.sqrt(4), 2)
+  })
+
+  it('bar', () => {
+    expect(1 + 1).eq(2)
+  })
+
+  it('snapshot', () => {
+    expect({ foo: 'bar' }).toMatchSnapshot()
+  })
+})
+```
+
+```bash
+$ npx vitest
+```
+
+## TODO
+
+- [ ] Reporter & Better output
+- [ ] CLI Help
+- [ ] Task filter
+- [ ] Mock
+- [ ] JSDom
+- [ ] Watch
+- [ ] Coverage
+
+## Sponsors
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/antfu/static/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/antfu/static/sponsors.svg'/>
+  </a>
+</p>
+
+## License
+
+[MIT](./LICENSE) License © 2021 [Anthony Fu](https://github.com/antfu)

package/bin/vitest.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+'use strict'
+
+import { fileURLToPath } from 'url'
+import { resolve, dirname } from 'path'
+import { run } from 'vite-node'
+import minimist from 'minimist'
+
+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())
+
+await run({
+  root,
+  files: [
+    resolve(__dirname, argv.dev ? '../src/cli.ts' : '../dist/cli.js'),
+  ],
+  config: resolve(root, argv.config || 'vitest.config.ts'),
+  defaultConfig: {
+    optimizeDeps: {
+      exclude: [
+        'vitest',
+      ],
+    },
+  },
+  shouldExternalize(id) {
+    if (id.includes('/node_modules/vitest/'))
+      return false
+    else
+      return id.includes('/node_modules/')
+  },
+})

package/dist/chai.d.ts

@@ -0,0 +1,12 @@
+export { assert, should, expect } from 'chai';
+declare global {
+    namespace Chai {
+        interface Assertion {
+            toMatchSnapshot(message?: string): Assertion;
+            matchSnapshot(message?: string): Assertion;
+        }
+        interface ExpectStatic {
+            addSnapshotSerializer: import('pretty-format').Plugin;
+        }
+    }
+}

package/dist/chai.js

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

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,28 @@
+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',
+    },
+    string: ['root', 'config'],
+    boolean: ['update', 'dev'],
+    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({}, testOptions), { updateSnapshot: argv.update, rootDir: argv.root || process.cwd() }));
+function help() {
+    log('Help: finish help');
+}

package/dist/config.d.ts

@@ -0,0 +1,17 @@
+import { UserConfig } from 'vite';
+import { UserOptions } from './types';
+export interface VitestConfig extends UserConfig {
+    /**
+     * Options for Vitest
+     */
+    test?: UserOptions;
+}
+export declare function defineConfig(config: VitestConfig): VitestConfig;
+declare module 'vite' {
+    interface UserConfig {
+        /**
+         * Options for Vitest
+         */
+        test?: UserOptions;
+    }
+}

package/dist/config.js

@@ -0,0 +1,3 @@
+export function defineConfig(config) {
+    return config;
+}

package/dist/context.d.ts

@@ -0,0 +1,2 @@
+import { GlobalContext } from './types';
+export declare const context: GlobalContext;

package/dist/context.js

@@ -0,0 +1,4 @@
+export const context = {
+    suites: [],
+    currentSuite: null,
+};

package/dist/hooks.d.ts

@@ -0,0 +1,50 @@
+import { Suite, Task } from './types';
+import { TaskResult } from '.';
+export declare const beforeHook: {
+    on(fn: (...args: any[]) => void | Promise<void>): void;
+    fire(...args: any[]): Promise<void>;
+    clear(): void;
+};
+export declare const afterHook: {
+    on(fn: (...args: any[]) => void | Promise<void>): void;
+    fire(...args: any[]): Promise<void>;
+    clear(): void;
+};
+export declare const beforeEachHook: {
+    on(fn: (args_0: Task) => void | Promise<void>): void;
+    fire(args_0: Task): Promise<void>;
+    clear(): void;
+};
+export declare const afterEachHook: {
+    on(fn: (args_0: Task, args_1: TaskResult) => void | Promise<void>): void;
+    fire(args_0: Task, args_1: TaskResult): Promise<void>;
+    clear(): void;
+};
+export declare const beforeFileHook: {
+    on(fn: (args_0: string) => void | Promise<void>): void;
+    fire(args_0: string): Promise<void>;
+    clear(): void;
+};
+export declare const afterFileHook: {
+    on(fn: (args_0: string) => void | Promise<void>): void;
+    fire(args_0: string): Promise<void>;
+    clear(): void;
+};
+export declare const beforeSuiteHook: {
+    on(fn: (args_0: Suite) => void | Promise<void>): void;
+    fire(args_0: Suite): Promise<void>;
+    clear(): void;
+};
+export declare const afterSuiteHook: {
+    on(fn: (args_0: Suite) => void | Promise<void>): void;
+    fire(args_0: Suite): Promise<void>;
+    clear(): void;
+};
+export declare const before: (fn: (...args: any[]) => void | Promise<void>) => void;
+export declare const after: (fn: (...args: any[]) => void | Promise<void>) => void;
+export declare const beforeEach: (fn: (args_0: Task) => void | Promise<void>) => void;
+export declare const afterEach: (fn: (args_0: Task, args_1: TaskResult) => void | Promise<void>) => void;
+export declare const beforeFile: (fn: (args_0: string) => void | Promise<void>) => void;
+export declare const afterFile: (fn: (args_0: string) => void | Promise<void>) => void;
+export declare const beforeSuite: (fn: (args_0: Suite) => void | Promise<void>) => void;
+export declare const afterSuite: (fn: (args_0: Suite) => void | Promise<void>) => void;

package/dist/hooks.js

@@ -0,0 +1,17 @@
+import { createHook } from './utils/hook';
+export const beforeHook = createHook();
+export const afterHook = createHook();
+export const beforeEachHook = createHook();
+export const afterEachHook = createHook();
+export const beforeFileHook = createHook();
+export const afterFileHook = createHook();
+export const beforeSuiteHook = createHook();
+export const afterSuiteHook = createHook();
+export const before = beforeHook.on;
+export const after = afterHook.on;
+export const beforeEach = beforeEachHook.on;
+export const afterEach = afterEachHook.on;
+export const beforeFile = beforeFileHook.on;
+export const afterFile = afterFileHook.on;
+export const beforeSuite = beforeSuiteHook.on;
+export const afterSuite = afterSuiteHook.on;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './suite';
+export * from './config';
+export * from './chai';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './suite';
+export * from './config';
+export * from './chai';

package/dist/run.d.ts

@@ -0,0 +1,5 @@
+import { File, Options, Task, TaskResult } from './types';
+export declare function runTasks(tasks: Task[]): Promise<TaskResult[]>;
+export declare function parseFile(filepath: string): Promise<File>;
+export declare function runFile(filepath: string): Promise<void>;
+export declare function run(options?: Options): Promise<void>;

package/dist/run.js

@@ -0,0 +1,94 @@
+import { relative } from 'path';
+import c from 'picocolors';
+import chai from 'chai';
+import fg from 'fast-glob';
+import { clearContext, defaultSuite } from './suite';
+import { context } from './context';
+import { afterEachHook, afterFileHook, afterHook, afterSuiteHook, beforeEachHook, beforeFileHook, beforeHook, beforeSuiteHook } from './hooks';
+import { SnapshotPlugin } from './snapshot/index';
+export async function runTasks(tasks) {
+    const results = [];
+    for (const task of tasks) {
+        const result = { task };
+        await beforeEachHook.fire(task);
+        try {
+            await task.fn();
+        }
+        catch (e) {
+            result.error = e;
+        }
+        results.push(result);
+        await afterEachHook.fire(task, result);
+    }
+    return results;
+}
+// TODO: REPORTER
+const { log } = console;
+export async function parseFile(filepath) {
+    clearContext();
+    await import(filepath);
+    const suites = [defaultSuite, ...context.suites];
+    const tasks = await Promise.all(suites.map(async (suite) => {
+        await beforeSuiteHook.fire(suite);
+        context.currentSuite = suite;
+        return [suite, await suite.collect()];
+    }));
+    const file = {
+        filepath,
+        suites,
+        tasks,
+    };
+    file.tasks.forEach(([, tasks]) => tasks.forEach(task => task.file = file));
+    return file;
+}
+export async function runFile(filepath) {
+    await beforeFileHook.fire(filepath);
+    const file = await parseFile(filepath);
+    for (const [suite, tasks] of file.tasks) {
+        let indent = 1;
+        if (suite.name) {
+            log(' '.repeat(indent * 2) + suite.name);
+            indent += 1;
+        }
+        const result = await runTasks(tasks);
+        for (const r of result) {
+            if (r.error === undefined) {
+                log(`${' '.repeat(indent * 2)}${c.inverse(c.green(' PASS '))} ${c.green(r.task.name)}`);
+            }
+            else {
+                console.error(`${' '.repeat(indent * 2)}${c.inverse(c.red(' FAIL '))} ${c.red(r.task.name)}`);
+                console.error(' '.repeat((indent + 2) * 2) + c.red(String(r.error)));
+                process.exitCode = 1;
+            }
+        }
+        if (suite.name)
+            indent -= 1;
+        await afterSuiteHook.fire(suite);
+    }
+    await afterFileHook.fire(filepath);
+}
+export async function run(options = {}) {
+    const { rootDir = process.cwd() } = options;
+    chai.use(SnapshotPlugin({
+        rootDir,
+        update: options.updateSnapshot,
+    }));
+    const files = await fg(options.includes || ['**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'], {
+        absolute: true,
+        cwd: options.rootDir,
+        ignore: options.excludes || ['/node_modules/', '/dist/'],
+    });
+    if (!files.length) {
+        console.error('No test files found');
+        process.exitCode = 1;
+        return;
+    }
+    await beforeHook.fire();
+    for (const file of files) {
+        log(`${relative(process.cwd(), file)}`);
+        await runFile(file);
+        log();
+    }
+    await afterHook.fire();
+    log();
+}

package/dist/snapshot/index.d.ts

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

package/dist/snapshot/index.js

@@ -0,0 +1,39 @@
+import Snap from 'jest-snapshot';
+import { after, before, beforeEach } from '../hooks';
+import { SnapshotManager } from './manager';
+const { addSerializer } = Snap;
+let _manager;
+export function SnapshotPlugin(options) {
+    const { rootDir } = options;
+    _manager = new SnapshotManager({
+        rootDir,
+        update: options.update,
+    });
+    return function (chai, utils) {
+        before(async () => {
+            _manager.snapshotResolver = await Snap.buildSnapshotResolver({
+                transform: [],
+                rootDir,
+            });
+        });
+        beforeEach((task) => {
+            var _a;
+            _manager.setContext({
+                file: ((_a = task.file) === null || _a === void 0 ? void 0 : _a.filepath) || task.name,
+                title: task.name,
+                fullTitle: [task.suite.name, task.name].filter(Boolean).join(' > '),
+            });
+        });
+        after(() => {
+            _manager.saveSnap();
+            _manager.report();
+        });
+        for (const key of ['matchSnapshot', 'toMatchSnapshot']) {
+            utils.addMethod(chai.Assertion.prototype, key, function (message) {
+                const expected = utils.flag(this, 'object');
+                _manager.assert(expected, message);
+            });
+        }
+        chai.expect.addSnapshotSerializer = addSerializer;
+    };
+}

package/dist/snapshot/manager.d.ts

@@ -0,0 +1,27 @@
+import type { SnapshotStateType, SnapshotResolver } from 'jest-snapshot';
+import type { SnapshotStateOptions } from 'jest-snapshot/build/State';
+import { SnapshotSummary } from './utils/types';
+export interface Context {
+    file: string;
+    title?: string;
+    fullTitle?: string;
+}
+export declare class SnapshotManager {
+    snapshotState: SnapshotStateType | null;
+    snapshotSummary: SnapshotSummary;
+    snapshotOptions: SnapshotStateOptions;
+    context: Context | null;
+    testFile: string;
+    snapshotResolver: SnapshotResolver | null;
+    rootDir: string;
+    constructor({ rootDir, update, snapshotResolver, }: {
+        rootDir: string;
+        update?: boolean;
+        snapshotResolver?: SnapshotResolver | null;
+    });
+    onFileChanged(): void;
+    setContext(context: Context): void;
+    assert(received: unknown, message: string): void;
+    saveSnap(): void;
+    report(): void;
+}

package/dist/snapshot/manager.js

@@ -0,0 +1,67 @@
+import chai from 'chai';
+import Snap from 'jest-snapshot';
+import { packSnapshotState, addSnapshotResult, makeEmptySnapshotSummary, } from './utils/jest-test-result-helper';
+import { getSnapshotSummaryOutput } from './utils/jest-reporters-lite';
+const { expect } = chai;
+const { SnapshotState } = Snap;
+export class SnapshotManager {
+    constructor({ rootDir, update, snapshotResolver = null, }) {
+        this.snapshotState = null;
+        this.context = null;
+        this.testFile = '';
+        this.rootDir = rootDir;
+        this.snapshotResolver = snapshotResolver;
+        const env = process.env;
+        const CI = !!env.CI;
+        const UPDATE_SNAPSHOT = update || env.UPDATE_SNAPSHOT;
+        this.snapshotOptions = {
+            updateSnapshot: CI && !UPDATE_SNAPSHOT
+                ? 'none'
+                : UPDATE_SNAPSHOT
+                    ? 'all'
+                    : 'new',
+        };
+        this.snapshotSummary = makeEmptySnapshotSummary(this.snapshotOptions);
+    }
+    onFileChanged() {
+        if (!this.context)
+            return;
+        if (this.snapshotState !== null)
+            this.saveSnap();
+        this.testFile = this.context.file;
+        this.snapshotState = new SnapshotState(this.snapshotResolver.resolveSnapshotPath(this.testFile), this.snapshotOptions);
+    }
+    setContext(context) {
+        if (!context.title || !context.file)
+            return;
+        this.context = context;
+        if (this.testFile !== context.file)
+            this.onFileChanged();
+    }
+    assert(received, message) {
+        if (!this.snapshotState || !this.context)
+            return;
+        const { actual, expected, key, pass } = this.snapshotState.match({
+            testName: this.context.fullTitle || this.context.title || this.context.file,
+            received,
+            isInline: false,
+        });
+        if (!pass) {
+            expect(actual.trim()).equals(expected ? expected.trim() : '', message || `Snapshot name: \`${key}\``);
+        }
+    }
+    saveSnap() {
+        if (!this.testFile || !this.snapshotState)
+            return;
+        const packedSnapshotState = packSnapshotState(this.snapshotState);
+        addSnapshotResult(this.snapshotSummary, packedSnapshotState, this.testFile);
+        this.testFile = '';
+        this.snapshotState = null;
+    }
+    report() {
+        const outputs = getSnapshotSummaryOutput(this.rootDir, this.snapshotSummary);
+        if (outputs.length > 1)
+            // eslint-disable-next-line no-console
+            console.log(`\n${outputs.join('\n')}`);
+    }
+}

package/dist/snapshot/utils/SnapshotResult.js

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

package/dist/snapshot/utils/jest-config-helper.d.ts

@@ -0,0 +1,3 @@
+export declare const replaceRootDirInPath: (rootDir: string, filePath: string) => string;
+export declare function replaceRootDirInObject<T>(rootDir: string, config: T): T;
+export declare function _replaceRootDirTags<T>(rootDir: string, config: T): T;

package/dist/snapshot/utils/jest-config-helper.js

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import path from 'path';
+export const replaceRootDirInPath = (rootDir, filePath) => {
+    if (!/^<rootDir>/.test(filePath))
+        return filePath;
+    return path.resolve(rootDir, path.normalize(`./${filePath.substr('<rootDir>'.length)}`));
+};
+export function replaceRootDirInObject(rootDir, config) {
+    const newConfig = {};
+    for (const configKey of Object.keys(config)) {
+        newConfig[configKey]
+            = configKey === 'rootDir'
+                ? config[configKey]
+                : _replaceRootDirTags(rootDir, config[configKey]);
+    }
+    return newConfig;
+}
+export function _replaceRootDirTags(rootDir, config) {
+    if (config == null)
+        return config;
+    switch (typeof config) {
+        case 'object':
+            if (Array.isArray(config)) {
+                /// can be string[] or {}[]
+                return config.map(item => _replaceRootDirTags(rootDir, item));
+            }
+            if (config instanceof RegExp)
+                return config;
+            return replaceRootDirInObject(rootDir, config);
+        case 'string':
+            return replaceRootDirInPath(rootDir, config);
+    }
+    return config;
+}

package/dist/snapshot/utils/jest-reporters-lite.d.ts

@@ -0,0 +1,2 @@
+import { SnapshotSummary } from './types';
+export declare const getSnapshotSummaryOutput: (rootDir: string, snapshots: SnapshotSummary) => Array<string>;

package/dist/snapshot/utils/jest-reporters-lite.js

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import path, { isAbsolute } from 'path';
+import { pluralize } from 'jest-util';
+import slash from 'slash';
+import c from 'picocolors';
+const formatTestPath = (rootDir, testPath) => {
+    if (isAbsolute(testPath))
+        testPath = path.relative(rootDir, testPath);
+    const dirname = path.dirname(testPath);
+    const basename = path.basename(testPath);
+    return slash(c.dim(dirname + path.sep) + c.bold(basename));
+};
+const ARROW = ' \u203A ';
+const DOWN_ARROW = ' \u21B3 ';
+const DOT = ' \u2022 ';
+const FAIL_COLOR = (v) => c.bold(c.red(v));
+const OBSOLETE_COLOR = (v) => c.bold(c.yellow(v));
+const SNAPSHOT_ADDED = (v) => c.bold(c.green(v));
+const SNAPSHOT_NOTE = c.dim;
+const SNAPSHOT_REMOVED = (v) => c.bold(c.green(v));
+const SNAPSHOT_SUMMARY = c.bold;
+const SNAPSHOT_UPDATED = (v) => c.bold(c.green(v));
+const updateCommand = 're-run mocha with `--update` to update them';
+export const getSnapshotSummaryOutput = (rootDir, snapshots) => {
+    const summary = [];
+    summary.push(SNAPSHOT_SUMMARY('Snapshot Summary'));
+    if (snapshots.added) {
+        summary.push(`${SNAPSHOT_ADDED(`${ARROW + pluralize('snapshot', snapshots.added)} written `)}from ${pluralize('test suite', snapshots.filesAdded)}.`);
+    }
+    if (snapshots.unmatched) {
+        summary.push(`${FAIL_COLOR(`${ARROW}${pluralize('snapshot', snapshots.unmatched)} failed`)} from ${pluralize('test suite', snapshots.filesUnmatched)}. ${SNAPSHOT_NOTE(`Inspect your code changes or ${updateCommand} to update them.`)}`);
+    }
+    if (snapshots.updated) {
+        summary.push(`${SNAPSHOT_UPDATED(`${ARROW + pluralize('snapshot', snapshots.updated)} updated `)}from ${pluralize('test suite', snapshots.filesUpdated)}.`);
+    }
+    if (snapshots.filesRemoved) {
+        if (snapshots.didUpdate) {
+            summary.push(`${SNAPSHOT_REMOVED(`${ARROW}${pluralize('snapshot file', snapshots.filesRemoved)} removed `)}from ${pluralize('test suite', snapshots.filesRemoved)}.`);
+        }
+        else {
+            summary.push(`${OBSOLETE_COLOR(`${ARROW}${pluralize('snapshot file', snapshots.filesRemoved)} obsolete `)}from ${pluralize('test suite', snapshots.filesRemoved)}. ${SNAPSHOT_NOTE(`To remove ${snapshots.filesRemoved === 1 ? 'it' : 'them all'}, ${updateCommand}.`)}`);
+        }
+    }
+    if (snapshots.filesRemovedList && snapshots.filesRemovedList.length) {
+        const [head, ...tail] = snapshots.filesRemovedList;
+        summary.push(`  ${DOWN_ARROW} ${DOT}${formatTestPath(rootDir, head)}`);
+        tail.forEach((key) => {
+            summary.push(`      ${DOT}${formatTestPath(rootDir, key)}`);
+        });
+    }
+    if (snapshots.unchecked) {
+        if (snapshots.didUpdate) {
+            summary.push(`${SNAPSHOT_REMOVED(`${ARROW}${pluralize('snapshot', snapshots.unchecked)} removed `)}from ${pluralize('test suite', snapshots.uncheckedKeysByFile.length)}.`);
+        }
+        else {
+            summary.push(`${OBSOLETE_COLOR(`${ARROW}${pluralize('snapshot', snapshots.unchecked)} obsolete `)}from ${pluralize('test suite', snapshots.uncheckedKeysByFile.length)}. ${SNAPSHOT_NOTE(`To remove ${snapshots.unchecked === 1 ? 'it' : 'them all'}, ${updateCommand}.`)}`);
+        }
+        snapshots.uncheckedKeysByFile.forEach((uncheckedFile) => {
+            summary.push(`  ${DOWN_ARROW}${formatTestPath(rootDir, uncheckedFile.filePath)}`);
+            uncheckedFile.keys.forEach((key) => {
+                summary.push(`      ${DOT}${key}`);
+            });
+        });
+    }
+    return summary;
+};

package/dist/snapshot/utils/jest-test-result-helper.d.ts

@@ -0,0 +1,6 @@
+import { SnapshotStateType } from 'jest-snapshot';
+import { SnapshotStateOptions } from 'jest-snapshot/build/State';
+import { SnapshotSummary, SnapshotResult } from './types';
+export declare const makeEmptySnapshotSummary: (options: SnapshotStateOptions) => SnapshotSummary;
+export declare const packSnapshotState: (snapshotState: SnapshotStateType) => SnapshotResult;
+export declare const addSnapshotResult: (snapshotSummary: SnapshotSummary, snapshotResult: SnapshotResult, testFilePath: string) => void;

package/dist/snapshot/utils/jest-test-result-helper.js

@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import Test from '@jest/test-result';
+const { makeEmptyAggregatedTestResult, } = Test;
+export const makeEmptySnapshotSummary = (options) => {
+    const summary = makeEmptyAggregatedTestResult().snapshot;
+    summary.didUpdate = options.updateSnapshot === 'all';
+    return summary;
+};
+export const packSnapshotState = (snapshotState) => {
+    const snapshot = {
+        added: 0,
+        fileDeleted: false,
+        matched: 0,
+        unchecked: 0,
+        uncheckedKeys: [],
+        unmatched: 0,
+        updated: 0,
+    };
+    const uncheckedCount = snapshotState.getUncheckedCount();
+    const uncheckedKeys = snapshotState.getUncheckedKeys();
+    if (uncheckedCount)
+        snapshotState.removeUncheckedKeys();
+    const status = snapshotState.save();
+    snapshot.fileDeleted = status.deleted;
+    snapshot.added = snapshotState.added;
+    snapshot.matched = snapshotState.matched;
+    snapshot.unmatched = snapshotState.unmatched;
+    snapshot.updated = snapshotState.updated;
+    snapshot.unchecked = !status.deleted ? uncheckedCount : 0;
+    // Copy the array to prevent memory leaks
+    snapshot.uncheckedKeys = Array.from(uncheckedKeys);
+    return snapshot;
+};
+export const addSnapshotResult = (snapshotSummary, snapshotResult, testFilePath) => {
+    // Snapshot data
+    if (snapshotResult.added)
+        snapshotSummary.filesAdded++;
+    if (snapshotResult.fileDeleted)
+        snapshotSummary.filesRemoved++;
+    if (snapshotResult.unmatched)
+        snapshotSummary.filesUnmatched++;
+    if (snapshotResult.updated)
+        snapshotSummary.filesUpdated++;
+    snapshotSummary.added += snapshotResult.added;
+    snapshotSummary.matched += snapshotResult.matched;
+    snapshotSummary.unchecked += snapshotResult.unchecked;
+    if (snapshotResult.uncheckedKeys && snapshotResult.uncheckedKeys.length > 0) {
+        snapshotSummary.uncheckedKeysByFile.push({
+            filePath: testFilePath,
+            keys: snapshotResult.uncheckedKeys,
+        });
+    }
+    snapshotSummary.unmatched += snapshotResult.unmatched;
+    snapshotSummary.updated += snapshotResult.updated;
+    snapshotSummary.total
+        += snapshotResult.added
+            + snapshotResult.matched
+            + snapshotResult.unmatched
+            + snapshotResult.updated;
+};

package/dist/snapshot/utils/tyoes.js

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

package/dist/snapshot/utils/types.d.ts

@@ -0,0 +1,29 @@
+export interface SnapshotResult {
+    added: number;
+    fileDeleted: boolean;
+    matched: number;
+    unchecked: number;
+    uncheckedKeys: Array<string>;
+    unmatched: number;
+    updated: number;
+}
+export interface UncheckedSnapshot {
+    filePath: string;
+    keys: Array<string>;
+}
+export interface SnapshotSummary {
+    added: number;
+    didUpdate: boolean;
+    failure: boolean;
+    filesAdded: number;
+    filesRemoved: number;
+    filesRemovedList: Array<string>;
+    filesUnmatched: number;
+    filesUpdated: number;
+    matched: number;
+    total: number;
+    unchecked: number;
+    uncheckedKeysByFile: Array<UncheckedSnapshot>;
+    unmatched: number;
+    updated: number;
+}

package/dist/snapshot/utils/types.js

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

package/dist/suite.d.ts

@@ -0,0 +1,7 @@
+import { Suite } from './types';
+export declare const defaultSuite: Suite;
+export declare const test: (name: string, fn: () => Promise<void> | void) => void;
+export declare function clearContext(): void;
+export declare function suite(suiteName: string, factory?: (test: Suite['test']) => Promise<void> | void): Suite;
+export declare const describe: typeof suite;
+export declare const it: (name: string, fn: () => Promise<void> | void) => void;

package/dist/suite.js

@@ -0,0 +1,41 @@
+import { context } from './context';
+export const defaultSuite = suite('');
+export const test = (name, fn) => (context.currentSuite || defaultSuite).test(name, fn);
+export function clearContext() {
+    context.suites.length = 0;
+    defaultSuite.clear();
+}
+export function suite(suiteName, factory) {
+    const queue = [];
+    const factoryQueue = [];
+    const suite = {
+        name: suiteName,
+        test,
+        collect,
+        clear,
+    };
+    function test(name, fn) {
+        const task = {
+            suite,
+            name,
+            fn,
+        };
+        queue.push(task);
+    }
+    function clear() {
+        queue.length = 0;
+        factoryQueue.length = 0;
+    }
+    async function collect() {
+        factoryQueue.length = 0;
+        if (factory)
+            await factory(test);
+        return [...factoryQueue, ...queue];
+    }
+    context.currentSuite = suite;
+    context.suites.push(suite);
+    return suite;
+}
+// alias
+export const describe = suite;
+export const it = test;

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+export interface UserOptions {
+    includes?: string[];
+    excludes?: string[];
+}
+export interface Options extends UserOptions {
+    rootDir?: string;
+    updateSnapshot?: boolean;
+}
+export interface Task {
+    name: string;
+    suite: Suite;
+    fn: () => Promise<void> | void;
+    file?: File;
+}
+export interface TaskResult {
+    task: Task;
+    error?: unknown;
+}
+export interface Suite {
+    name: string;
+    test: (name: string, fn: () => Promise<void> | void) => void;
+    collect: () => Promise<Task[]>;
+    clear: () => void;
+}
+export interface File {
+    filepath: string;
+    suites: Suite[];
+    tasks: [Suite, Task[]][];
+}
+export interface GlobalContext {
+    suites: Suite[];
+    currentSuite: Suite | null;
+}

package/dist/types.js

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

package/dist/utils/hook.d.ts

@@ -0,0 +1,5 @@
+export declare function createHook<T extends any[]>(): {
+    on(fn: (...args: T) => void | Promise<void>): void;
+    fire(...args: T): Promise<void>;
+    clear(): void;
+};

package/dist/utils/hook.js

@@ -0,0 +1,14 @@
+export function createHook() {
+    const stacks = [];
+    return {
+        on(fn) {
+            stacks.push(fn);
+        },
+        async fire(...args) {
+            await Promise.all(stacks.map(async (fn) => await fn(...args)));
+        },
+        clear() {
+            stacks.length = 0;
+        },
+    };
+}

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "vitest",
-  "version": "0.0.0",
-  "main": "index.js",
-  "license": "MIT"
+  "version": "0.0.4",
+  "type": "module",
+  "description": "",
+  "keywords": [],
+  "homepage": "https://github.com/antfu/vitest#readme",
+  "bugs": {
+    "url": "https://github.com/antfu/vitest/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/antfu/vitest.git"
+  },
+  "funding": "https://github.com/sponsors/antfu",
+  "license": "MIT",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./*": "./*"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "bin": {
+    "vitest": "./bin/vitest.mjs"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "lint": "eslint \"{src,test}/**/*.ts\"",
+    "prepublishOnly": "nr build",
+    "release": "bumpp --commit --push --tag && pnpm publish",
+    "test": "node bin/vitest.mjs --dev",
+    "test:update": "nr test -u"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^0.11.1",
+    "@antfu/ni": "^0.11.0",
+    "@types/minimist": "^1.2.2",
+    "@types/node": "^16.11.11",
+    "bumpp": "^7.1.1",
+    "eslint": "^8.3.0",
+    "esno": "^0.12.1",
+    "typescript": "^4.5.2",
+    "vite": "^2.6.14"
+  },
+  "dependencies": {
+    "@types/chai": "^4.2.22",
+    "@jest/test-result": "^27.4.2",
+    "chai": "^4.3.4",
+    "fast-glob": "^3.2.7",
+    "jest-snapshot": "^27.4.2",
+    "jest-util": "^27.4.2",
+    "minimist": "^1.2.5",
+    "picocolors": "^1.0.0",
+    "vite-node": "^0.1.9"
+  }
 }