vitest 0.0.35 → 0.0.36

package/dist/reporters/error.js

@@ -1,183 +0,0 @@
-/* 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) {
-    var _a;
-    if (!(error instanceof Error)) {
-        console.error(error);
-        return;
-    }
-    const { moduleCache } = process.__vite_node__;
-    const e = error;
-    let codeFramePrinted = false;
-    const stacks = parseStack(e.stack || '');
-    const nearest = stacks.find(stack => moduleCache.has(stack.file));
-    if (nearest) {
-        const transformResult = (_a = moduleCache.get(nearest.file)) === null || _a === void 0 ? void 0 : _a.transformResult;
-        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.d.ts

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

package/dist/run/index.js

@@ -1,271 +0,0 @@
-import fg from 'fast-glob';
-import { slash } from '@antfu/utils';
-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.mode = 'skip'));
-        else
-            interpretOnlyMode(i.tasks);
-        i.tasks.forEach(t => t.mode === 'skip' && (t.state = 'skip'));
-    });
-    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 runSuite(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]);
-            for (const taskGroup of partitionTasks(suite.tasks)) {
-                if (taskGroup[0].concurrent) {
-                    await Promise.all(taskGroup.map(t => runTask(t, ctx)));
-                }
-                else {
-                    for (const t of taskGroup)
-                        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));
-}
-/**
- * Partition consecutive serial and concurrent tasks in groups
- */
-function partitionTasks(tasks) {
-    let taskGroup = [];
-    const groupedTasks = [];
-    for (const task of tasks) {
-        if (taskGroup.length === 0 || !!task.concurrent === !!taskGroup[0].concurrent) {
-            taskGroup.push(task);
-        }
-        else {
-            groupedTasks.push(taskGroup);
-            taskGroup = [task];
-        }
-    }
-    if (taskGroup.length > 0)
-        groupedTasks.push(taskGroup);
-    return groupedTasks;
-}
-export async function runFile(file, ctx) {
-    var _a, _b;
-    const { reporter } = ctx;
-    const runnableSuites = file.suites.filter(i => i.mode === 'run');
-    if (runnableSuites.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 => runSuite(suite, ctx)));
-    }
-    else {
-        for (const suite of file.suites)
-            await runSuite(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;
-    config.reporter = config.reporter || new DefaultReporter();
-    const { reporter } = config;
-    // 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.root,
-        ignore: config.excludes || defaultExcludes,
-    });
-    // if name filters are provided by the CLI
-    if ((_a = config.filters) === null || _a === void 0 ? void 0 : _a.length)
-        testFilepaths = testFilepaths.filter(i => config.filters.some(f => i.includes(f)));
-    if (!testFilepaths.length) {
-        console.error('No test files found');
-        process.exitCode = 1;
-        return;
-    }
-    // setup envs
-    if (config.global)
-        (await import('../integrations/global')).registerApiGlobally();
-    if (config.dom === 'happy-dom')
-        (await import('../integrations/dom/happy-dom')).setupHappyDOM(globalThis);
-    else if (config.dom)
-        (await import('../integrations/dom/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() {
-            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,
-        snapshotManager,
-    };
-    await runFiles(filesMap, ctx);
-    snapshotManager.saveSnap();
-    await ((_c = reporter.onFinished) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
-    if (config.watch)
-        await startWatcher(ctx);
-}
-export async function startWatcher(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 = slash(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;
-            if (changedTests.size === 0)
-                return;
-            snapshotManager.clear();
-            const paths = Array.from(changedTests);
-            changedTests.clear();
-            await ((_a = reporter.onWatcherRerun) === null || _a === void 0 ? void 0 : _a.call(reporter, paths, id, ctx));
-            paths.forEach(i => moduleCache.delete(i));
-            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 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/suite.d.ts

@@ -1,56 +0,0 @@
-import { SuiteCollector, TestFactory, TestFunction, Suite } from './types';
-export declare const defaultSuite: SuiteCollector;
-export declare const test: {
-    (name: string, fn: TestFunction): void;
-    concurrent: {
-        (name: string, fn: TestFunction, timeout?: number | undefined): void;
-        skip(name: string, fn: TestFunction, timeout?: number | undefined): void;
-        only(name: string, fn: TestFunction, timeout?: number | undefined): void;
-        todo(name: string): void;
-    };
-    skip: {
-        (name: string, fn: TestFunction): void;
-        concurrent(name: string, fn: TestFunction, timeout?: number | undefined): void;
-    };
-    only: {
-        (name: string, fn: TestFunction): void;
-        concurrent(name: string, fn: TestFunction, timeout?: number | undefined): void;
-    };
-    todo: {
-        (name: string): void;
-        concurrent(name: string): void;
-    };
-};
-export declare function suite(suiteName: string, factory?: TestFactory): SuiteCollector;
-export declare namespace suite {
-    var skip: (suiteName: string, factory?: TestFactory | undefined) => SuiteCollector;
-    var only: (suiteName: string, factory?: TestFactory | undefined) => SuiteCollector;
-    var todo: (suiteName: string) => SuiteCollector;
-}
-export declare const describe: typeof suite;
-export declare const it: {
-    (name: string, fn: TestFunction): void;
-    concurrent: {
-        (name: string, fn: TestFunction, timeout?: number | undefined): void;
-        skip(name: string, fn: TestFunction, timeout?: number | undefined): void;
-        only(name: string, fn: TestFunction, timeout?: number | undefined): void;
-        todo(name: string): void;
-    };
-    skip: {
-        (name: string, fn: TestFunction): void;
-        concurrent(name: string, fn: TestFunction, timeout?: number | undefined): void;
-    };
-    only: {
-        (name: string, fn: TestFunction): void;
-        concurrent(name: string, fn: TestFunction, timeout?: number | undefined): void;
-    };
-    todo: {
-        (name: string): void;
-        concurrent(name: string): void;
-    };
-};
-export declare const beforeAll: (fn: Suite['hooks']['beforeAll'][0]) => void;
-export declare const afterAll: (fn: Suite['hooks']['afterAll'][0]) => void;
-export declare const beforeEach: (fn: Suite['hooks']['beforeEach'][0]) => void;
-export declare const afterEach: (fn: Suite['hooks']['afterEach'][0]) => void;
-export declare function clearContext(): void;

package/dist/suite.js

@@ -1,142 +0,0 @@
-import { context } from './context';
-import { defaultConcurrentTimeout } from './constants';
-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 test = createTestCollector((name, fn, mode, concurrent) => {
-        queue.push({
-            name,
-            mode,
-            concurrent,
-            suite: {},
-            state: (mode !== 'run' && mode !== 'only') ? mode : undefined,
-            fn,
-        });
-    });
-    const collector = {
-        name,
-        mode,
-        test,
-        collect,
-        clear,
-        on: addHook,
-    };
-    function addHook(name, ...fn) {
-        suiteBase.hooks[name].push(...fn);
-    }
-    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;
-}
-function createConcurrentOptions(timeout) {
-    return { timeout: timeout !== null && timeout !== void 0 ? timeout : defaultConcurrentTimeout };
-}
-function createTestCollector(collectTask) {
-    function test(name, fn) {
-        collectTask(name, fn, 'run');
-    }
-    test.concurrent = concurrent;
-    test.skip = skip;
-    test.only = only;
-    test.todo = todo;
-    function concurrent(name, fn, timeout) {
-        collectTask(name, fn, 'run', createConcurrentOptions(timeout));
-    }
-    concurrent.skip = (name, fn, timeout) => collectTask(name, fn, 'skip', createConcurrentOptions(timeout));
-    concurrent.only = (name, fn, timeout) => collectTask(name, fn, 'only', createConcurrentOptions(timeout));
-    concurrent.todo = todo;
-    function skip(name, fn) {
-        collectTask(name, fn, 'skip');
-    }
-    skip.concurrent = concurrent.skip;
-    function only(name, fn) {
-        collectTask(name, fn, 'only');
-    }
-    only.concurrent = concurrent.only;
-    function todo(name) {
-        collectTask(name, () => { }, 'todo');
-    }
-    todo.concurrent = todo;
-    return test;
-}
-// apis
-export const test = (function () {
-    function test(name, fn) {
-        return getCurrentSuite().test(name, fn);
-    }
-    function concurrent(name, fn, timeout) {
-        return getCurrentSuite().test.concurrent(name, fn, timeout);
-    }
-    concurrent.skip = (name, fn, timeout) => getCurrentSuite().test.concurrent.skip(name, fn, timeout);
-    concurrent.only = (name, fn, timeout) => getCurrentSuite().test.concurrent.only(name, fn, timeout);
-    concurrent.todo = (name) => getCurrentSuite().test.concurrent.todo(name);
-    function skip(name, fn) {
-        return getCurrentSuite().test.skip(name, fn);
-    }
-    skip.concurrent = (name, fn, timeout) => getCurrentSuite().test.skip.concurrent(name, fn, timeout);
-    function only(name, fn) {
-        return getCurrentSuite().test.only(name, fn);
-    }
-    only.concurrent = (name, fn, timeout) => getCurrentSuite().test.only.concurrent(name, fn, timeout);
-    function todo(name) {
-        return getCurrentSuite().test.todo(name);
-    }
-    todo.concurrent = (name) => getCurrentSuite().test.todo.concurrent(name);
-    test.concurrent = concurrent;
-    test.skip = skip;
-    test.only = only;
-    test.todo = todo;
-    return test;
-})();
-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.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;
-        },
-    };
-}