vitest 0.0.32 → 0.0.36

package/dist/suite.js

@@ -1,91 +0,0 @@
-import { context } from './context';
-export const defaultSuite = suite('');
-function getCurrentSuite() {
-    return context.currentSuite || defaultSuite;
-}
-function createSuiteCollector(name, factory = () => { }, mode) {
-    const queue = [];
-    const factoryQueue = [];
-    const suiteBase = {
-        name,
-        mode,
-        hooks: {
-            beforeAll: [],
-            afterAll: [],
-            beforeEach: [],
-            afterEach: [],
-        },
-    };
-    const collector = {
-        name,
-        mode,
-        test,
-        collect,
-        clear,
-        on: addHook,
-    };
-    function addHook(name, ...fn) {
-        suiteBase.hooks[name].push(...fn);
-    }
-    function collectTask(name, fn, mode) {
-        queue.push({
-            name,
-            mode,
-            suite: {},
-            state: (mode !== 'run' && mode !== 'only') ? mode : undefined,
-            fn,
-        });
-    }
-    function test(name, fn) {
-        collectTask(name, fn, 'run');
-    }
-    test.skip = (name, fn) => collectTask(name, fn, 'skip');
-    test.only = (name, fn) => collectTask(name, fn, 'only');
-    test.todo = (name) => collectTask(name, () => { }, 'todo');
-    function clear() {
-        queue.length = 0;
-        factoryQueue.length = 0;
-    }
-    async function collect(file) {
-        factoryQueue.length = 0;
-        if (factory)
-            await factory(test);
-        const tasks = [...factoryQueue, ...queue];
-        const suite = Object.assign(Object.assign({}, suiteBase), { tasks,
-            file });
-        tasks.forEach((task) => {
-            task.suite = suite;
-            if (file)
-                task.file = file;
-        });
-        return suite;
-    }
-    context.currentSuite = collector;
-    context.suites.push(collector);
-    return collector;
-}
-// apis
-export const test = (name, fn) => getCurrentSuite().test(name, fn);
-test.skip = (name, fn) => getCurrentSuite().test.skip(name, fn);
-test.only = (name, fn) => getCurrentSuite().test.only(name, fn);
-test.todo = (name) => getCurrentSuite().test.todo(name);
-export function suite(suiteName, factory) {
-    return createSuiteCollector(suiteName, factory, 'run');
-}
-suite.skip = (suiteName, factory) => createSuiteCollector(suiteName, factory, 'skip');
-suite.only = (suiteName, factory) => createSuiteCollector(suiteName, factory, 'only');
-suite.todo = (suiteName) => createSuiteCollector(suiteName, undefined, 'todo');
-// alias
-export const describe = suite;
-export const it = test;
-// hooks
-export const beforeAll = (fn) => getCurrentSuite().on('beforeAll', fn);
-export const afterAll = (fn) => getCurrentSuite().on('afterAll', fn);
-export const beforeEach = (fn) => getCurrentSuite().on('beforeEach', fn);
-export const afterEach = (fn) => getCurrentSuite().on('afterEach', fn);
-// utils
-export function clearContext() {
-    context.suites.length = 0;
-    defaultSuite.clear();
-    context.currentSuite = defaultSuite;
-}

package/dist/types.d.ts

@@ -1,138 +0,0 @@
-import { SnapshotManager } from './integrations/chai/snapshot/manager';
-export declare type Awaitable<T> = Promise<T> | T;
-export interface UserOptions {
-    /**
-     * Include globs for test files
-     *
-     * @default ['**\/*.test.ts']
-     */
-    includes?: string[];
-    /**
-     * Exclude globs for test files
-     * @default ['**\/node_modules\/**']
-     */
-    excludes?: string[];
-    /**
-     * Handling for dependencies inlining or externalizing
-     */
-    deps?: {
-        external?: (string | RegExp)[];
-        inline?: (string | RegExp)[];
-    };
-    /**
-     * Register apis globally
-     *
-     * @default false
-     */
-    global?: boolean;
-    /**
-     * Use `js-dom` to mock browser APIs
-     *
-     * @default false
-     */
-    jsdom?: boolean;
-    /**
-     * Run tests files in parallel
-     *
-     * @default false
-     */
-    parallel?: boolean;
-    /**
-     * Update snapshot files
-     *
-     * @default false
-     */
-    update?: boolean;
-    /**
-     * Watch mode
-     *
-     * @default false
-     */
-    watch?: boolean;
-    /**
-     * Project root
-     */
-    root?: string;
-    /**
-     * Custom reporter for output
-     */
-    reporter?: Reporter;
-}
-export interface ResolvedConfig extends Required<UserOptions> {
-    filters?: string[];
-    config?: string;
-}
-export declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
-export declare type TaskState = RunMode | 'pass' | 'fail';
-export interface Task {
-    name: string;
-    mode: RunMode;
-    suite: Suite;
-    fn: () => Awaitable<void>;
-    file?: File;
-    state?: TaskState;
-    error?: unknown;
-}
-export declare type TestFunction = () => Awaitable<void>;
-export interface TestCollector {
-    (name: string, fn: TestFunction): void;
-    only: (name: string, fn: TestFunction) => void;
-    skip: (name: string, fn: TestFunction) => void;
-    todo: (name: string) => void;
-}
-export declare type HookListener<T extends any[]> = (...args: T) => Awaitable<void>;
-export interface Suite {
-    name: string;
-    mode: RunMode;
-    tasks: Task[];
-    file?: File;
-    error?: unknown;
-    status?: TaskState;
-    hooks: {
-        beforeAll: HookListener<[Suite]>[];
-        afterAll: HookListener<[Suite]>[];
-        beforeEach: HookListener<[Task, Suite]>[];
-        afterEach: HookListener<[Task, Suite]>[];
-    };
-}
-export interface SuiteCollector {
-    readonly name: string;
-    readonly mode: RunMode;
-    test: TestCollector;
-    collect: (file?: File) => Promise<Suite>;
-    clear: () => void;
-    on: <T extends keyof Suite['hooks']>(name: T, ...fn: Suite['hooks'][T]) => void;
-}
-export declare type TestFactory = (test: (name: string, fn: TestFunction) => void) => Awaitable<void>;
-export interface File {
-    filepath: string;
-    suites: Suite[];
-    collected: boolean;
-    error?: unknown;
-}
-export interface RunnerContext {
-    filesMap: Record<string, File>;
-    files: File[];
-    suites: Suite[];
-    tasks: Task[];
-    config: ResolvedConfig;
-    reporter: Reporter;
-    snapshotManager: SnapshotManager;
-}
-export interface GlobalContext {
-    suites: SuiteCollector[];
-    currentSuite: SuiteCollector | null;
-}
-export interface Reporter {
-    onStart?: (config: ResolvedConfig) => Awaitable<void>;
-    onCollected?: (files: File[], 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>;
-    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>;
-}

package/dist/types.js

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

package/dist/utils/hook.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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;
-        },
-    };
-}