@japa/runner 2.5.1 → 3.0.0-1

package/build/modules/core/main.js

@@ -0,0 +1,68 @@
+import { Emitter, Refiner, Test as BaseTest, Suite as BaseSuite, Group as BaseGroup, Runner as BaseRunner, TestContext as BaseTestContext, } from '@japa/core';
+import { inspect } from 'node:util';
+import { AssertionError } from 'node:assert';
+import { BaseReporter } from './reporters/base.js';
+export { Emitter, Refiner, BaseReporter };
+export class TestContext extends BaseTestContext {
+    test;
+    constructor(test) {
+        super();
+        this.test = test;
+        this.cleanup = (cleanupCallback) => {
+            test.cleanup(cleanupCallback);
+        };
+    }
+}
+export class Test extends BaseTest {
+    static executedCallbacks = [];
+    static executingCallbacks = [];
+    throws(message, errorConstructor) {
+        const errorInPoint = new AssertionError({});
+        const existingExecutor = this.options.executor;
+        if (!existingExecutor) {
+            throw new Error('Cannot use "test.throws" method without a test callback');
+        }
+        this.options.executor = async (...args) => {
+            let raisedException;
+            try {
+                await existingExecutor(...args);
+            }
+            catch (error) {
+                raisedException = error;
+            }
+            if (!raisedException) {
+                errorInPoint.message = 'Expected test to throw an exception';
+                throw errorInPoint;
+            }
+            if (errorConstructor && !(raisedException instanceof errorConstructor)) {
+                errorInPoint.message = `Expected test to throw "${inspect(errorConstructor)}"`;
+                throw errorInPoint;
+            }
+            const exceptionMessage = raisedException.message;
+            if (!exceptionMessage || typeof exceptionMessage !== 'string') {
+                errorInPoint.message = 'Expected test to throw an exception with message property';
+                throw errorInPoint;
+            }
+            if (typeof message === 'string') {
+                if (exceptionMessage !== message) {
+                    errorInPoint.message = `Expected test to throw "${message}". Instead received "${raisedException.message}"`;
+                    errorInPoint.actual = raisedException.message;
+                    errorInPoint.expected = message;
+                    throw errorInPoint;
+                }
+                return;
+            }
+            if (!message.test(exceptionMessage)) {
+                errorInPoint.message = `Expected test error to match "${message}" regular expression`;
+                throw errorInPoint;
+            }
+        };
+        return this;
+    }
+}
+export class Group extends BaseGroup {
+}
+export class Suite extends BaseSuite {
+}
+export class Runner extends BaseRunner {
+}

package/build/modules/core/reporters/base.d.ts

@@ -0,0 +1,21 @@
+import type { TestEndNode, SuiteEndNode, GroupEndNode, TestStartNode, RunnerSummary, RunnerEndNode, GroupStartNode, SuiteStartNode, RunnerStartNode, BaseReporterOptions } from '../types.js';
+import { Emitter, Runner } from '../main.js';
+export declare abstract class BaseReporter {
+    #private;
+    runner?: Runner;
+    currentFileName?: string;
+    currentSuiteName?: string;
+    currentGroupName?: string;
+    constructor(options?: BaseReporterOptions);
+    protected onTestStart(_: TestStartNode): void;
+    protected onTestEnd(_: TestEndNode): void;
+    protected onGroupStart(_: GroupStartNode): void;
+    protected onGroupEnd(_: GroupEndNode): void;
+    protected onSuiteStart(_: SuiteStartNode): void;
+    protected onSuiteEnd(_: SuiteEndNode): void;
+    protected start(_: RunnerStartNode): Promise<void>;
+    protected end(_: RunnerEndNode): Promise<void>;
+    protected printSummary(summary: RunnerSummary): Promise<void>;
+    boot(runner: Runner, emitter: Emitter): void;
+}
+//# sourceMappingURL=base.d.ts.map

package/build/modules/core/reporters/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../modules/core/reporters/base.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,aAAa,EACb,aAAa,EACb,cAAc,EACd,cAAc,EACd,eAAe,EACf,mBAAmB,EACpB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAO5C,8BAAsB,YAAY;;IAEhC,MAAM,CAAC,EAAE,MAAM,CAAA;IAKf,eAAe,CAAC,EAAE,MAAM,CAAA;IAKxB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAKzB,gBAAgB,CAAC,EAAE,MAAM,CAAA;gBAEb,OAAO,GAAE,mBAAwB;IAsG7C,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,aAAa,GAAG,IAAI;IAC7C,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,WAAW;IAElC,SAAS,CAAC,YAAY,CAAC,CAAC,EAAE,cAAc;IACxC,SAAS,CAAC,UAAU,CAAC,CAAC,EAAE,YAAY;IAEpC,SAAS,CAAC,YAAY,CAAC,CAAC,EAAE,cAAc;IACxC,SAAS,CAAC,UAAU,CAAC,CAAC,EAAE,YAAY;cAEpB,KAAK,CAAC,CAAC,EAAE,eAAe;cACxB,GAAG,CAAC,CAAC,EAAE,aAAa;cAKpB,YAAY,CAAC,OAAO,EAAE,aAAa;IAqBnD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;CAyCtC"}

package/build/modules/core/reporters/base.js

@@ -0,0 +1,136 @@
+import ms from 'ms';
+import colors from '@poppinss/colors';
+import { ErrorsPrinter } from '@japa/errors-printer';
+const ansi = colors.ansi();
+export class BaseReporter {
+    #options;
+    runner;
+    currentFileName;
+    currentSuiteName;
+    currentGroupName;
+    constructor(options = {}) {
+        this.#options = Object.assign({ stackLinesCount: 2 }, options);
+    }
+    #printAggregates(summary) {
+        const tests = [];
+        if (summary.aggregates.passed) {
+            tests.push(ansi.green(`${summary.aggregates.passed} passed`));
+        }
+        if (summary.aggregates.failed) {
+            tests.push(ansi.red(`${summary.aggregates.failed} failed`));
+        }
+        if (summary.aggregates.todo) {
+            tests.push(ansi.cyan(`${summary.aggregates.todo} todo`));
+        }
+        if (summary.aggregates.skipped) {
+            tests.push(ansi.yellow(`${summary.aggregates.skipped} skipped`));
+        }
+        if (summary.aggregates.regression) {
+            tests.push(ansi.magenta(`${summary.aggregates.regression} regression`));
+        }
+        this.runner.summaryBuilder.use(() => {
+            return [
+                {
+                    key: ansi.dim('Tests'),
+                    value: `${tests.join(', ')} ${ansi.dim(`(${summary.aggregates.total})`)}`,
+                },
+                {
+                    key: ansi.dim('Time'),
+                    value: ansi.dim(ms(summary.duration)),
+                },
+            ];
+        });
+        console.log(this.runner.summaryBuilder.build().join('\n'));
+    }
+    #aggregateErrors(summary) {
+        const errorsList = [];
+        summary.failureTree.forEach((suite) => {
+            suite.errors.forEach((error) => errorsList.push({ title: suite.name, ...error }));
+            suite.children.forEach((testOrGroup) => {
+                if (testOrGroup.type === 'test') {
+                    testOrGroup.errors.forEach((error) => {
+                        errorsList.push({ title: `${suite.name} / ${testOrGroup.title}`, ...error });
+                    });
+                    return;
+                }
+                testOrGroup.errors.forEach((error) => {
+                    errorsList.push({ title: testOrGroup.name, ...error });
+                });
+                testOrGroup.children.forEach((test) => {
+                    test.errors.forEach((error) => {
+                        errorsList.push({ title: `${testOrGroup.name} / ${test.title}`, ...error });
+                    });
+                });
+            });
+        });
+        return errorsList;
+    }
+    async #printErrors(summary) {
+        if (!summary.failureTree.length) {
+            return;
+        }
+        const errorPrinter = new ErrorsPrinter({
+            stackLinesCount: this.#options.stackLinesCount,
+            framesMaxLimit: this.#options.framesMaxLimit,
+        });
+        errorPrinter.printSectionHeader('ERRORS');
+        await errorPrinter.printErrors(this.#aggregateErrors(summary));
+    }
+    onTestStart(_) { }
+    onTestEnd(_) { }
+    onGroupStart(_) { }
+    onGroupEnd(_) { }
+    onSuiteStart(_) { }
+    onSuiteEnd(_) { }
+    async start(_) { }
+    async end(_) { }
+    async printSummary(summary) {
+        await this.#printErrors(summary);
+        console.log('');
+        if (summary.aggregates.total === 0 && !summary.hasError) {
+            console.log(ansi.bgYellow().black(' NO TESTS EXECUTED '));
+            return;
+        }
+        if (summary.hasError) {
+            console.log(ansi.bgRed().black(' FAILED '));
+        }
+        else {
+            console.log(ansi.bgGreen().black(' PASSED '));
+        }
+        console.log('');
+        this.#printAggregates(summary);
+    }
+    boot(runner, emitter) {
+        this.runner = runner;
+        emitter.on('test:start', (payload) => {
+            this.currentFileName = payload.meta.fileName;
+            this.onTestStart(payload);
+        });
+        emitter.on('test:end', (payload) => {
+            this.onTestEnd(payload);
+        });
+        emitter.on('group:start', (payload) => {
+            this.currentGroupName = payload.title;
+            this.currentFileName = payload.meta.fileName;
+            this.onGroupStart(payload);
+        });
+        emitter.on('group:end', (payload) => {
+            this.currentGroupName = undefined;
+            this.onGroupEnd(payload);
+        });
+        emitter.on('suite:start', (payload) => {
+            this.currentSuiteName = payload.name;
+            this.onSuiteStart(payload);
+        });
+        emitter.on('suite:end', (payload) => {
+            this.currentSuiteName = undefined;
+            this.onSuiteEnd(payload);
+        });
+        emitter.on('runner:start', async (payload) => {
+            await this.start(payload);
+        });
+        emitter.on('runner:end', async (payload) => {
+            await this.end(payload);
+        });
+    }
+}

package/build/modules/core/types.d.ts

@@ -0,0 +1,6 @@
+export * from '@japa/core/types';
+export type BaseReporterOptions = {
+    stackLinesCount?: number;
+    framesMaxLimit?: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/build/modules/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../modules/core/types.ts"],"names":[],"mappings":"AASA,cAAc,kBAAkB,CAAA;AAEhC,MAAM,MAAM,mBAAmB,GAAG;IAChC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA"}

package/build/modules/core/types.js

@@ -0,0 +1 @@
+export * from '@japa/core/types';

package/build/src/cli_parser.d.ts

@@ -0,0 +1,6 @@
+import type { CLIArgs } from './types.js';
+export declare class CliParser {
+    parse(argv: string[]): CLIArgs;
+    getHelp(): string;
+}
+//# sourceMappingURL=cli_parser.d.ts.map

package/build/src/cli_parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli_parser.d.ts","sourceRoot":"","sources":["../../src/cli_parser.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAsDzC,qBAAa,SAAS;IAIpB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO;IAO9B,OAAO;CAGR"}

package/build/src/cli_parser.js

@@ -0,0 +1,49 @@
+import getopts from 'getopts';
+import colors from '@poppinss/colors';
+const ansi = colors.ansi();
+const OPTIONS = {
+    string: ['tests', 'groups', 'tags', 'files', 'timeout', 'retries', 'reporter'],
+    boolean: ['help', 'matchAll'],
+    alias: {
+        forceExit: 'force-exit',
+        matchAll: 'match-all',
+        help: 'h',
+    },
+};
+const GET_HELP = () => `
+${ansi.yellow('@japa/runner v2.3.0')}
+
+${ansi.green('--tests')}                     ${ansi.dim('Filter tests by the test title')}
+${ansi.green('--groups')}                    ${ansi.dim('Filter tests by the group title')}
+${ansi.green('--tags')}                      ${ansi.dim('Filter tests by tags')}
+${ansi.green('--files')}                     ${ansi.dim('Filter tests by the file name')}
+${ansi.green('--force-exit')}                ${ansi.dim('Forcefully exit the process')}
+${ansi.green('--timeout')}                   ${ansi.dim('Define default timeout for all tests')}
+${ansi.green('--retries')}                   ${ansi.dim('Define default retries for all tests')}
+${ansi.green('--reporter')}                  ${ansi.dim('Activate one or more test reporters')}
+${ansi.green('-h, --help')}                  ${ansi.dim('View help')}
+
+${ansi.yellow('Examples:')}
+${ansi.dim('node bin/test.js --tags="@github"')}
+${ansi.dim('node bin/test.js --tags="~@github"')}
+${ansi.dim('node bin/test.js --tags="@github,@slow,@integration" --match-all')}
+${ansi.dim('node bin/test.js --force-exit')}
+${ansi.dim('node bin/test.js --files="user"')}
+${ansi.dim('node bin/test.js --files="functional/user"')}
+${ansi.dim('node bin/test.js --files="unit/user"')}
+
+${ansi.yellow('Notes:')}
+- When groups and tests filters are applied together. We will first filter the
+  tests by group title and then apply the tests title filter.
+- The timeout defined on test object takes precedence over the ${ansi.green('--timeout')} flag.
+- The retries defined on test object takes precedence over the ${ansi.green('--retries')} flag.
+- The ${ansi.green('--files')} flag checks for the file names ending with the filter substring.
+`;
+export class CliParser {
+    parse(argv) {
+        return getopts(argv, OPTIONS);
+    }
+    getHelp() {
+        return GET_HELP();
+    }
+}

package/build/src/config_manager.d.ts

@@ -0,0 +1,7 @@
+import type { CLIArgs, Config } from './types.js';
+export declare class ConfigManager {
+    #private;
+    constructor(config: Config, cliArgs: CLIArgs);
+    hydrate(): Required<Config>;
+}
+//# sourceMappingURL=config_manager.d.ts.map

package/build/src/config_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config_manager.d.ts","sourceRoot":"","sources":["../../src/config_manager.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAW,MAAM,YAAY,CAAA;AA0B1D,qBAAa,aAAa;;gBAIZ,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;IAsF5C,OAAO,IAAI,QAAQ,CAAC,MAAM,CAAC;CAoD5B"}

package/build/src/config_manager.js

@@ -0,0 +1,115 @@
+import debug from './debug.js';
+import { spec } from './reporters/main.js';
+import { Refiner } from '../modules/core/main.js';
+const DEFAULTS = {
+    files: [],
+    timeout: 2000,
+    retries: 0,
+    forceExit: false,
+    plugins: [],
+    reporters: {
+        activated: ['spec'],
+        list: [spec()],
+    },
+    importer: (filePath) => import(filePath.href),
+    configureSuite: () => { },
+};
+export class ConfigManager {
+    #config;
+    #cliArgs;
+    constructor(config, cliArgs) {
+        this.#config = config;
+        this.#cliArgs = cliArgs;
+    }
+    #processAsArray(value) {
+        return Array.isArray(value) ? value : value.split(',').map((item) => item.trim());
+    }
+    #getCLIFilters() {
+        const filters = {};
+        if (this.#cliArgs.tags) {
+            filters.tags = this.#processAsArray(this.#cliArgs.tags);
+        }
+        if (this.#cliArgs.tests) {
+            filters.tests = this.#processAsArray(this.#cliArgs.tests);
+        }
+        if (this.#cliArgs.files) {
+            filters.files = this.#processAsArray(this.#cliArgs.files);
+        }
+        if (this.#cliArgs.groups) {
+            filters.groups = this.#processAsArray(this.#cliArgs.groups);
+        }
+        if (this.#cliArgs._ && this.#cliArgs._.length) {
+            filters.suites = this.#processAsArray(this.#cliArgs._);
+        }
+        return filters;
+    }
+    #getCLITimeout() {
+        if (this.#cliArgs.timeout) {
+            const value = Number(this.#cliArgs.timeout);
+            if (!Number.isNaN(value)) {
+                return value;
+            }
+        }
+    }
+    #getCLIRetries() {
+        if (this.#cliArgs.retries) {
+            const value = Number(this.#cliArgs.retries);
+            if (!Number.isNaN(value)) {
+                return value;
+            }
+        }
+    }
+    #getCLIForceExit() {
+        if (this.#cliArgs.forceExit) {
+            return true;
+        }
+    }
+    #getCLIReporters() {
+        if (this.#cliArgs.reporter) {
+            return this.#processAsArray(this.#cliArgs.reporter);
+        }
+    }
+    hydrate() {
+        const cliFilters = this.#getCLIFilters();
+        const cliRetries = this.#getCLIRetries();
+        const cliTimeout = this.#getCLITimeout();
+        const cliReporters = this.#getCLIReporters();
+        const cliForceExit = this.#getCLIForceExit();
+        debug('filters applied using CLI flags %O', cliFilters);
+        const baseConfig = {
+            cwd: this.#config.cwd ?? process.cwd(),
+            filters: Object.assign({}, this.#config.filters ?? {}, cliFilters),
+            importer: this.#config.importer ?? DEFAULTS.importer,
+            refiner: this.#config.refiner ?? new Refiner(),
+            retries: cliRetries ?? this.#config.retries ?? DEFAULTS.retries,
+            timeout: cliTimeout ?? this.#config.timeout ?? DEFAULTS.timeout,
+            plugins: this.#config.plugins ?? DEFAULTS.plugins,
+            forceExit: cliForceExit ?? this.#config.forceExit ?? DEFAULTS.forceExit,
+            reporters: this.#config.reporters ?? DEFAULTS.reporters,
+            configureSuite: this.#config.configureSuite ?? DEFAULTS.configureSuite,
+            setup: this.#config.setup || [],
+            teardown: this.#config.teardown || [],
+        };
+        if (cliReporters) {
+            baseConfig.reporters.activated = cliReporters;
+        }
+        if ('files' in this.#config) {
+            return {
+                files: this.#config.files,
+                ...baseConfig,
+            };
+        }
+        return {
+            suites: this.#config.suites.map((suite) => {
+                return {
+                    name: suite.name,
+                    files: suite.files,
+                    timeout: cliTimeout ?? suite.timeout ?? baseConfig.timeout,
+                    retries: cliRetries ?? suite.retries ?? baseConfig.retries,
+                    configure: suite.configure,
+                };
+            }),
+            ...baseConfig,
+        };
+    }
+}

package/build/src/create_test.d.ts

@@ -0,0 +1,16 @@
+import { Emitter, Group, Refiner, Suite, Test } from '../modules/core/main.js';
+export declare function createTest(title: string, emitter: Emitter, refiner: Refiner, options: {
+    group?: Group;
+    suite?: Suite;
+    file?: string;
+    timeout?: number;
+    retries?: number;
+}): Test<undefined>;
+export declare function createTestGroup(title: string, emitter: Emitter, refiner: Refiner, options: {
+    group?: Group;
+    suite?: Suite;
+    file?: string;
+    timeout?: number;
+    retries?: number;
+}): Group;
+//# sourceMappingURL=create_test.d.ts.map

package/build/src/create_test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_test.d.ts","sourceRoot":"","sources":["../../src/create_test.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAe,MAAM,yBAAyB,CAAA;AAU3F,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE;IACP,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,mBAwBF;AAKD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE;IACP,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,SAeF"}

package/build/src/create_test.js

@@ -0,0 +1,33 @@
+import { Group, Test, TestContext } from '../modules/core/main.js';
+const contextBuilder = (testInstance) => new TestContext(testInstance);
+export function createTest(title, emitter, refiner, options) {
+    const testInstance = new Test(title, contextBuilder, emitter, refiner, options.group);
+    testInstance.options.meta.suite = options.suite;
+    testInstance.options.meta.group = options.group;
+    testInstance.options.meta.fileName = options.file;
+    if (options.timeout !== undefined) {
+        testInstance.timeout(options.timeout);
+    }
+    if (options.retries !== undefined) {
+        testInstance.retry(options.retries);
+    }
+    if (options.group) {
+        options.group.add(testInstance);
+    }
+    else if (options.suite) {
+        options.suite.add(testInstance);
+    }
+    return testInstance;
+}
+export function createTestGroup(title, emitter, refiner, options) {
+    if (options.group) {
+        throw new Error('Nested groups are not supported by Japa');
+    }
+    const group = new Group(title, emitter, refiner);
+    group.options.meta.suite = options.suite;
+    group.options.meta.fileName = options.file;
+    if (options.suite) {
+        options.suite.add(group);
+    }
+    return group;
+}

package/build/src/debug.d.ts

@@ -1,3 +1,4 @@
-/// <reference types="node" />
+/// <reference types="@types/node" resolution-mode="require"/>
 declare const _default: import("util").DebugLogger;
 export default _default;
+//# sourceMappingURL=debug.d.ts.map

package/build/src/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../src/debug.ts"],"names":[],"mappings":";;AAUA,wBAAsC"}

package/build/src/debug.js

@@ -1,12 +1,2 @@
-"use strict";
-/*
- * @japa/runner
- *
- * (c) Japa.dev
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("util");
-exports.default = (0, util_1.debuglog)('japa:runner');
+import { debuglog } from 'node:util';
+export default debuglog('japa:runner');

package/build/src/exceptions_manager.d.ts

@@ -0,0 +1,7 @@
+export declare class ExceptionsManager {
+    #private;
+    hasErrors: boolean;
+    monitor(): void;
+    flow(): Promise<void>;
+}
+//# sourceMappingURL=exceptions_manager.d.ts.map

package/build/src/exceptions_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exceptions_manager.d.ts","sourceRoot":"","sources":["../../src/exceptions_manager.ts"],"names":[],"mappings":"AAeA,qBAAa,iBAAiB;;IAM5B,SAAS,EAAE,OAAO,CAAQ;IAW1B,OAAO;IAwBD,IAAI;CAmCX"}

package/build/src/exceptions_manager.js

@@ -0,0 +1,58 @@
+import { ErrorsPrinter } from '@japa/errors-printer';
+export class ExceptionsManager {
+    #exceptionsBuffer = [];
+    #rejectionsBuffer = [];
+    #state = 'watching';
+    #errorsPrinter = new ErrorsPrinter({ stackLinesCount: 2, framesMaxLimit: 4 });
+    hasErrors = false;
+    monitor() {
+        process.on('uncaughtException', async (error) => {
+            this.hasErrors = true;
+            if (this.#state === 'watching') {
+                this.#exceptionsBuffer.push(error);
+            }
+            else {
+                this.#errorsPrinter.printSectionBorder('[Unhandled Error]');
+                await this.#errorsPrinter.printError(error);
+                process.exitCode = 1;
+            }
+        });
+        process.on('unhandledRejection', async (error) => {
+            this.hasErrors = true;
+            if (this.#state === 'watching') {
+                this.#rejectionsBuffer.push(error);
+            }
+            else {
+                this.#errorsPrinter.printSectionBorder('[Unhandled Rejection]');
+                await this.#errorsPrinter.printError(error);
+                process.exitCode = 1;
+            }
+        });
+    }
+    async flow() {
+        if (this.#state === 'flowing') {
+            return;
+        }
+        this.#state = 'flowing';
+        if (this.#exceptionsBuffer.length) {
+            let exceptionsCount = this.#exceptionsBuffer.length;
+            let exceptionsIndex = this.#exceptionsBuffer.length;
+            this.#errorsPrinter.printSectionHeader('Unhandled Errors');
+            for (let exception of this.#exceptionsBuffer) {
+                await this.#errorsPrinter.printError(exception);
+                this.#errorsPrinter.printSectionBorder(`[${++exceptionsIndex}/${exceptionsCount}]`);
+            }
+            this.#exceptionsBuffer = [];
+        }
+        if (this.#rejectionsBuffer.length) {
+            let rejectionsCount = this.#exceptionsBuffer.length;
+            let rejectionsIndex = this.#exceptionsBuffer.length;
+            this.#errorsPrinter.printSectionBorder('Unhandled Rejections');
+            for (let rejection of this.#rejectionsBuffer) {
+                await this.#errorsPrinter.printError(rejection);
+                this.#errorsPrinter.printSectionBorder(`[${++rejectionsIndex}/${rejectionsCount}]`);
+            }
+            this.#rejectionsBuffer = [];
+        }
+    }
+}

package/build/src/files_manager.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="@types/node" resolution-mode="require"/>
+import type { TestFiles } from './types.js';
+export declare class FilesManager {
+    getFiles(cwd: string, files: TestFiles): Promise<URL[]>;
+    grep(files: URL[], filters: string[]): URL[];
+}
+//# sourceMappingURL=files_manager.d.ts.map

package/build/src/files_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files_manager.d.ts","sourceRoot":"","sources":["../../src/files_manager.ts"],"names":[],"mappings":";AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAY3C,qBAAa,YAAY;IAKjB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IAiB7D,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,GAAG,EAAE;CAY7C"}

package/build/src/files_manager.js

@@ -0,0 +1,28 @@
+import { sep } from 'node:path';
+import fastGlob from 'fast-glob';
+import { pathToFileURL } from 'node:url';
+const FILE_SUFFIX_EXPRESSION = /(\.spec|\.test)?\.[js|ts|jsx|tsx|mjs|mts|cjs|cts]+$/;
+export class FilesManager {
+    async getFiles(cwd, files) {
+        if (Array.isArray(files) || typeof files === 'string') {
+            const testFiles = await fastGlob(files, {
+                absolute: true,
+                onlyFiles: true,
+                cwd: cwd,
+            });
+            return testFiles.map((file) => pathToFileURL(file));
+        }
+        return await files();
+    }
+    grep(files, filters) {
+        return files.filter((file) => {
+            return !!filters.find((filter) => {
+                const filterSegments = filter.split('/').reverse();
+                const fileSegments = file.pathname.replace(FILE_SUFFIX_EXPRESSION, '').split(sep).reverse();
+                return filterSegments.every((segment, index) => {
+                    return fileSegments[index] && (segment === '*' || fileSegments[index].endsWith(segment));
+                });
+            });
+        });
+    }
+}

package/build/src/helpers.d.ts

@@ -0,0 +1,23 @@
+declare const _default: {
+    colors: import("@poppinss/colors/types").Colors;
+    logger: import("@poppinss/cliui").Logger;
+    table: (tableOptions?: Partial<import("@poppinss/cliui/types").TableOptions> | undefined) => import("@poppinss/cliui").Table;
+    tasks: (tasksOptions?: Partial<import("@poppinss/cliui/types").TaskManagerOptions> | undefined) => import("@poppinss/cliui").TaskManager;
+    icons: {
+        tick: string;
+        cross: string;
+        bullet: string;
+        nodejs: string;
+        pointer: string;
+        info: string;
+        warning: string;
+        squareSmallFilled: string;
+    };
+    sticker: () => import("@poppinss/cliui").Instructions;
+    instructions: () => import("@poppinss/cliui").Instructions;
+    switchMode(modeToUse: "raw" | "silent" | "normal"): void;
+    useRenderer(rendererToUse: import("@poppinss/cliui/types").RendererContract): void;
+    useColors(colorsToUse: import("@poppinss/colors/types").Colors): void;
+};
+export default _default;
+//# sourceMappingURL=helpers.d.ts.map

package/build/src/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/helpers.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAUA,wBAAsB"}

package/build/src/helpers.js

@@ -0,0 +1,2 @@
+import { cliui } from '@poppinss/cliui';
+export default cliui();