@unrift/core 0.0.0

package/dist/esm/runner.js

@@ -0,0 +1,207 @@
+import { relative, resolve } from "node:path";
+import { loadConfig, loadConfigFromPath, } from "./utils/loadConfig.js";
+import { cleanUnriftCaches } from "./utils/transform.js";
+import { colors } from "./utils/colors.js";
+import { discoverTestFiles } from "./utils/discoverTestFiles.js";
+import { runEngine } from "./run.js";
+import { TaskStatus } from "./types.js";
+function normalizePath(p) {
+    // stable for matching/reporting across platforms
+    return p.replace(/\\/g, "/");
+}
+function debugLog(enabled, json, ...args) {
+    // Keep stdout clean for --json mode; use stderr for debug.
+    if (!enabled)
+        return;
+    (json ? console.error : console.log)(...args);
+}
+function safeRegExp(source) {
+    try {
+        return new RegExp(source);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Invalid regex "${source}": ${msg}`);
+    }
+}
+/**
+ * @TODO Add glob support
+ */
+function matchesAnyPattern(fileAbs, patterns, baseDir) {
+    const absolutePath = normalizePath(fileAbs);
+    const relativePath = normalizePath(relative(baseDir, fileAbs));
+    return patterns.some((pattern) => {
+        const re = safeRegExp(pattern);
+        return re.test(relativePath) || re.test(absolutePath);
+    });
+}
+function filterByIncludesExcludes(files, baseDir, includes, excludes) {
+    let filtered = files;
+    if (includes && includes.length > 0) {
+        filtered = filtered.filter((file) => matchesAnyPattern(file, includes, baseDir));
+    }
+    if (excludes && excludes.length > 0) {
+        filtered = filtered.filter((file) => !matchesAnyPattern(file, excludes, baseDir));
+    }
+    return filtered;
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms.toFixed(0)}ms`;
+    return `${(ms / 1000).toFixed(2)}s`;
+}
+function padRight(str, width) {
+    return str.length >= width ? str : str + " ".repeat(width - str.length);
+}
+function getFileHeadingFromDescription(description) {
+    const index = description.indexOf("›");
+    if (index === -1)
+        return null;
+    return description.slice(0, index).trim();
+}
+export async function runTestsCLI(options = {}) {
+    const runStart = performance.now();
+    // Cache clean mode
+    if (options.cacheClean) {
+        const projectRoot = process.cwd();
+        const result = cleanUnriftCaches(projectRoot);
+        if (options.json) {
+            console.log(JSON.stringify({ ok: true, cleaned: result }, null, 2));
+        }
+        else {
+            const lines = [];
+            if (result.projectCacheDeleted)
+                lines.push("✔ deleted project cache");
+            if (result.tempCacheDeleted)
+                lines.push("✔ deleted temp cache");
+            if (lines.length === 0)
+                lines.push("— nothing to clean");
+            console.log(lines.join("\n"));
+        }
+        return;
+    }
+    // Load config and capture its directory so testDir can be relative to it
+    const loaded = options.configPath
+        ? await loadConfigFromPath(options.configPath)
+        : await loadConfig(process.cwd());
+    const config = loaded?.config ?? null;
+    const configDir = loaded?.configDir ?? process.cwd();
+    const resolvedConfigPath = loaded?.configPath ?? null;
+    debugLog(options.debug, options.json, "Using config:", {
+        configPath: resolvedConfigPath,
+        configDir,
+        config,
+    });
+    // Test dir is relative to config dir if config is loaded
+    const testDir = resolve(configDir, config?.testDir ?? options.testDir ?? "test");
+    let files = discoverTestFiles(testDir);
+    if (options.pattern) {
+        files = files.filter((f) => options.pattern.test(normalizePath(f)));
+    }
+    files = filterByIncludesExcludes(files, testDir, config?.includes, config?.excludes).sort((a, b) => normalizePath(a).localeCompare(normalizePath(b)));
+    debugLog(options.debug, options.json, "Discovered test files:", files);
+    // List mode
+    if (options.list) {
+        if (options.json) {
+            console.log(JSON.stringify({ files: files.map(normalizePath), count: files.length }, null, 2));
+        }
+        else {
+            for (const file of files)
+                console.log(file);
+            if (options.debug)
+                console.log(`\n${files.length} file(s)`);
+        }
+        return;
+    }
+    const timeoutMs = options.timeoutMs ?? config?.timeoutMs;
+    const bail = options.bail ?? config?.bail ?? false;
+    const engine = await runEngine({
+        files,
+        timeoutMs,
+        bail,
+        matchers: config?.matchers,
+    });
+    debugLog(options.debug, options.json, "Only mode:", engine.isOnly);
+    const results = engine.results;
+    let total = 0;
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    const failures = [];
+    const serializedResults = [];
+    for (const result of results) {
+        total++;
+        if (result.status === TaskStatus.Pass)
+            passed++;
+        else if (result.status === TaskStatus.Skipped)
+            skipped++;
+        else if (result.status === TaskStatus.Fail)
+            failed++;
+        if (result.status === TaskStatus.Fail)
+            failures.push(result);
+        serializedResults.push({
+            description: result.description,
+            status: result.status,
+            durationMs: result.durationMs ?? 0,
+            error: result.error
+                ? { message: result.error.message, stack: result.error.stack }
+                : undefined,
+        });
+    }
+    const ok = failed === 0;
+    const durationMs = performance.now() - runStart;
+    // JSON mode: stdout must be JSON only
+    if (options.json) {
+        const report = {
+            ok,
+            failed,
+            passed,
+            skipped,
+            total,
+            bail,
+            timeoutMs,
+            testDir: normalizePath(testDir),
+            configPath: resolvedConfigPath,
+            files: files.map(normalizePath),
+            durationMs,
+            results: serializedResults,
+        };
+        console.log(JSON.stringify(report, null, 2));
+        if (!ok)
+            process.exitCode = 1;
+        return;
+    }
+    // Standard reporting
+    const durationColWidth = 8;
+    let lastHeading = null;
+    for (const result of results) {
+        const heading = getFileHeadingFromDescription(result.description);
+        if (heading && heading !== lastHeading) {
+            console.log(colors.bold(`\n${heading}`));
+            lastHeading = heading;
+        }
+        const duration = formatDuration(result.durationMs ?? 0);
+        const durationPadded = padRight(duration, durationColWidth);
+        if (result.status === TaskStatus.Pass) {
+            console.log(colors.green("✔"), durationPadded, result.description.replace(/^.*?›\s*/, ""));
+            continue;
+        }
+        if (result.status === TaskStatus.Skipped) {
+            console.log(colors.yellow("↷"), padRight("—", durationColWidth), result.description.replace(/^.*?›\s*/, ""));
+            continue;
+        }
+        // Fail
+        console.log(colors.red("✘"), durationPadded, result.description.replace(/^.*?›\s*/, ""));
+    }
+    if (failures.length > 0) {
+        console.log(colors.bold("\nFailures:"));
+        failures.forEach((r, i) => {
+            console.log(colors.red(`\n${i + 1}) ${r.description}`));
+            if (r.error)
+                console.log(colors.red(r.error.stack ?? r.error.message));
+        });
+    }
+    console.log(colors.bold(`\nPassed: ${passed}  Failed: ${failed}  Skipped: ${skipped}  Total: ${total}  Time: ${formatDuration(durationMs)}\n`));
+    if (!ok)
+        process.exitCode = 1;
+}

package/dist/esm/suite.d.ts

@@ -0,0 +1,58 @@
+import { Test } from "./test";
+import { type PromisableFn, TaskMode, TaskStatus } from "./types";
+interface RunOptions {
+    timeoutMs?: number;
+    bail?: boolean;
+}
+interface SuiteRunState {
+    bailed: boolean;
+}
+interface SuiteTask {
+    description: string;
+    parent?: Suite;
+    suites: Suite[];
+    tests: Test[];
+    addSuite(suite: Suite): void;
+    addTest(test: Test): void;
+    run(): Promise<void>;
+}
+export declare class Suite implements SuiteTask {
+    description: string;
+    mode: TaskMode;
+    parent?: Suite;
+    subtreeHasOnly: boolean;
+    root: boolean;
+    errors: Array<{
+        label: string;
+        error: Error;
+    }>;
+    suites: Suite[];
+    tests: Test[];
+    afterAllError?: Error;
+    beforeAllError?: Error;
+    beforeAllHooks: PromisableFn<void>[];
+    afterAllHooks: PromisableFn<void>[];
+    beforeEachHooks: PromisableFn<void>[];
+    afterEachHooks: PromisableFn<void>[];
+    constructor(description: string, parent?: Suite, mode?: TaskMode);
+    markSubtreeSkipped(): void;
+    addSuite(suite: Suite): void;
+    addTest(test: Test): void;
+    private collectBeforeEachHooks;
+    private collectAfterEachHooks;
+    run(options?: RunOptions, state?: SuiteRunState, isOnly?: boolean, ancestorOnly?: boolean): Promise<void>;
+    getFullDescription(): string;
+    reset(): void;
+    getResults(): Array<{
+        description: string;
+        status: TaskStatus;
+        error?: Error;
+        durationMs: number;
+    }>;
+}
+export declare function computeOnlyFlags(suite: Suite): boolean;
+export declare const rootSuite: Suite;
+export declare function getCurrentSuite(): Suite;
+export declare function clearContext(): void;
+export {};
+//# sourceMappingURL=suite.d.ts.map

package/dist/esm/suite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suite.d.ts","sourceRoot":"","sources":["../../src/suite.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,OAAO,EAAE,KAAK,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAElE,UAAU,UAAU;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,UAAU,aAAa;IACrB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,UAAU,SAAS;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,IAAI,EAAE,CAAC;IAEd,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAC7B,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAE1B,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACtB;AAsBD,qBAAa,KAAM,YAAW,SAAS;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,CAAC,EAAE,KAAK,CAAC;IAEf,cAAc,EAAE,OAAO,CAAS;IAEhC,IAAI,EAAE,OAAO,CAAS;IACtB,MAAM,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC,CAAM;IACpD,MAAM,EAAE,KAAK,EAAE,CAAM;IACrB,KAAK,EAAE,IAAI,EAAE,CAAM;IAEnB,aAAa,CAAC,EAAE,KAAK,CAAC;IACtB,cAAc,CAAC,EAAE,KAAK,CAAC;IAEvB,cAAc,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE,CAAM;IAC1C,aAAa,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE,CAAM;IACzC,eAAe,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE,CAAM;IAC3C,cAAc,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE,CAAM;gBAGxC,WAAW,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,KAAK,EACd,IAAI,GAAE,QAA2B;IAO5B,kBAAkB;IASzB,QAAQ,CAAC,KAAK,EAAE,KAAK;IAIrB,OAAO,CAAC,IAAI,EAAE,IAAI;IAIlB,OAAO,CAAC,sBAAsB;IAiB9B,OAAO,CAAC,qBAAqB;IAYvB,GAAG,CACP,OAAO,CAAC,EAAE,UAAU,EACpB,KAAK,GAAE,aAAiC,EACxC,MAAM,GAAE,OAAe,EACvB,YAAY,GAAE,OAAe,GAC5B,OAAO,CAAC,IAAI,CAAC;IAwJhB,kBAAkB,IAAI,MAAM;IAK5B,KAAK;IAaL,UAAU,IAAI,KAAK,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,EAAE,UAAU,CAAC;QACnB,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;CAkDH;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAiBtD;AAED,eAAO,MAAM,SAAS,OAAoB,CAAC;AAG3C,wBAAgB,eAAe,UAE9B;AAED,wBAAgB,YAAY,SAI3B"}

package/dist/esm/suite.js

@@ -0,0 +1,281 @@
+import { unriftGlobalContext } from "./context.js";
+import { TaskMode, TaskStatus } from "./types.js";
+function appendHookFailure(existing, hookName, hookError) {
+    if (!existing)
+        return hookError;
+    const primaryMsg = existing.message || String(existing);
+    const hookMsg = hookError.message || String(hookError);
+    const combined = new Error(`${primaryMsg}\n\n[${hookName}] ${hookMsg}`);
+    const primaryStack = existing.stack ?? primaryMsg;
+    const hookStack = hookError.stack ?? hookMsg;
+    combined.stack = `${primaryStack}\n\n[${hookName}] ${hookStack}`;
+    return combined;
+}
+export class Suite {
+    description;
+    mode;
+    parent;
+    subtreeHasOnly = false;
+    root = false;
+    errors = [];
+    suites = [];
+    tests = [];
+    afterAllError;
+    beforeAllError;
+    beforeAllHooks = [];
+    afterAllHooks = [];
+    beforeEachHooks = [];
+    afterEachHooks = [];
+    constructor(description, parent, mode = TaskMode.Default) {
+        this.description = description;
+        this.parent = parent;
+        this.mode = mode;
+    }
+    markSubtreeSkipped() {
+        for (const test of this.tests) {
+            if (test.status === TaskStatus.Pending)
+                test.status = TaskStatus.Skipped;
+            test.durationMs = 0;
+        }
+        for (const suite of this.suites)
+            suite.markSubtreeSkipped();
+    }
+    addSuite(suite) {
+        this.suites.push(suite);
+    }
+    addTest(test) {
+        this.tests.push(test);
+    }
+    collectBeforeEachHooks() {
+        const beforeEachHooks = [];
+        let currentSuite = this;
+        const stack = [];
+        while (currentSuite) {
+            stack.push(currentSuite);
+            currentSuite = currentSuite.parent;
+        }
+        for (let i = stack.length - 1; i >= 0; i--) {
+            beforeEachHooks.push(...stack[i].beforeEachHooks);
+        }
+        return beforeEachHooks;
+    }
+    collectAfterEachHooks() {
+        const afterEachHooks = [];
+        let currentSuite = this;
+        while (currentSuite) {
+            afterEachHooks.push(...currentSuite.afterEachHooks);
+            currentSuite = currentSuite.parent;
+        }
+        return afterEachHooks;
+    }
+    async run(options, state = { bailed: false }, isOnly = false, ancestorOnly = false) {
+        // Bail should mark anything not-run as skipped (no "pending" leaks).
+        if (state.bailed) {
+            this.markSubtreeSkipped();
+            return;
+        }
+        if (this.mode === TaskMode.Skip) {
+            this.markSubtreeSkipped();
+            return;
+        }
+        const suiteHasOnly = this.subtreeHasOnly;
+        const inOnlyContext = ancestorOnly || this.mode === TaskMode.Only;
+        // If only is on and this suite has no runnable-only content, skip it entirely
+        if (isOnly && !suiteHasOnly && !inOnlyContext) {
+            this.markSubtreeSkipped();
+            return;
+        }
+        let entered = false;
+        try {
+            // beforeAll
+            try {
+                for (const hook of this.beforeAllHooks) {
+                    await hook();
+                }
+            }
+            catch (error) {
+                this.beforeAllError =
+                    error instanceof Error ? error : new Error(String(error));
+                // Prevent "pending" tests from showing up if beforeAll fails
+                this.markSubtreeSkipped();
+                return;
+            }
+            entered = true;
+            const beforeEachHooks = this.collectBeforeEachHooks();
+            const afterEachHooks = this.collectAfterEachHooks();
+            // Indexed so we can skip remaining tests on bail
+            for (let i = 0; i < this.tests.length; i++) {
+                const test = this.tests[i];
+                if (state.bailed)
+                    break;
+                if (test.mode === TaskMode.Skip) {
+                    test.status = TaskStatus.Skipped;
+                    test.durationMs = 0;
+                    continue;
+                }
+                const testIsOnly = inOnlyContext || test.mode === TaskMode.Only;
+                // If onlyMode, skip tests that are not in only context
+                if (isOnly && !testIsOnly) {
+                    test.status = TaskStatus.Skipped;
+                    test.durationMs = 0;
+                    continue;
+                }
+                try {
+                    for (const hook of beforeEachHooks) {
+                        try {
+                            await hook();
+                        }
+                        catch (error) {
+                            const hookError = error instanceof Error ? error : new Error(String(error));
+                            throw appendHookFailure(undefined, "beforeEach", hookError);
+                        }
+                    }
+                    await test.run(options?.timeoutMs);
+                }
+                catch (error) {
+                    test.status = TaskStatus.Fail;
+                    test.error =
+                        error instanceof Error ? error : new Error(String(error));
+                }
+                finally {
+                    for (const hook of afterEachHooks) {
+                        try {
+                            await hook();
+                        }
+                        catch (error) {
+                            const hookError = error instanceof Error ? error : new Error(String(error));
+                            test.status = TaskStatus.Fail;
+                            test.error = appendHookFailure(test.error, "afterEach", hookError);
+                        }
+                    }
+                }
+                // Mark everything that hasn't run as skipped on bail
+                if (options?.bail && test.status === TaskStatus.Fail) {
+                    state.bailed = true;
+                    // Remaining tests in this suite
+                    for (let j = i + 1; j < this.tests.length; j++) {
+                        const t = this.tests[j];
+                        if (t.status === TaskStatus.Pending)
+                            t.status = TaskStatus.Skipped;
+                        t.durationMs = 0;
+                    }
+                    // All child suites won't run
+                    for (const child of this.suites)
+                        child.markSubtreeSkipped();
+                    break;
+                }
+            }
+            // Indexed so we can skip remaining suites on bail
+            for (let i = 0; i < this.suites.length; i++) {
+                const childSuite = this.suites[i];
+                if (state.bailed) {
+                    // Current and remaining suites won't run
+                    for (let j = i; j < this.suites.length; j++) {
+                        this.suites[j].markSubtreeSkipped();
+                    }
+                    break;
+                }
+                await childSuite.run(options, state, isOnly, inOnlyContext);
+            }
+        }
+        finally {
+            // afterAll should still run for suites we entered, even on bail,
+            // but it should not run for suites we haven't entered.
+            if (entered) {
+                for (const afterAllHook of this.afterAllHooks) {
+                    try {
+                        await afterAllHook();
+                    }
+                    catch (error) {
+                        // Record once; keep running remaining afterAll hooks
+                        if (!this.afterAllError) {
+                            this.afterAllError =
+                                error instanceof Error ? error : new Error(String(error));
+                        }
+                    }
+                }
+            }
+        }
+    }
+    getFullDescription() {
+        if (!this.parent || this.parent.root)
+            return this.description;
+        return `${this.parent.getFullDescription()} › ${this.description}`;
+    }
+    reset() {
+        this.tests = [];
+        this.suites = [];
+        this.beforeAllHooks = [];
+        this.afterAllHooks = [];
+        this.beforeEachHooks = [];
+        this.afterEachHooks = [];
+        this.afterAllError = undefined;
+        this.beforeAllError = undefined;
+        this.errors = [];
+        this.subtreeHasOnly = false;
+    }
+    getResults() {
+        let results = [];
+        for (const suiteError of this.errors) {
+            results.push({
+                description: `${this.getFullDescription()} > [${suiteError.label}]`,
+                status: TaskStatus.Fail,
+                error: suiteError.error,
+                durationMs: 0,
+            });
+        }
+        if (this.beforeAllError) {
+            results.push({
+                description: `${this.getFullDescription()} > [beforeAll]`,
+                status: TaskStatus.Fail,
+                error: this.beforeAllError,
+                durationMs: 0,
+            });
+        }
+        if (this.afterAllError) {
+            results.push({
+                description: `${this.getFullDescription()} > [afterAll]`,
+                status: TaskStatus.Fail,
+                error: this.afterAllError,
+                durationMs: 0,
+            });
+        }
+        for (const test of this.tests) {
+            results.push({
+                description: `${this.getFullDescription()} › ${test.description}`,
+                status: test.status,
+                error: test.error,
+                durationMs: test.durationMs ?? 0,
+            });
+        }
+        for (const child of this.suites) {
+            results = results.concat(child.getResults());
+        }
+        return results;
+    }
+}
+export function computeOnlyFlags(suite) {
+    // Clear any stale value first for multi-run in same process
+    suite.subtreeHasOnly = false;
+    let subtreeHasOnly = suite.mode === TaskMode.Only;
+    for (const test of suite.tests) {
+        if (test.mode === TaskMode.Only)
+            subtreeHasOnly = true;
+    }
+    for (const child of suite.suites) {
+        if (computeOnlyFlags(child))
+            subtreeHasOnly = true;
+    }
+    suite.subtreeHasOnly = subtreeHasOnly;
+    return subtreeHasOnly;
+}
+export const rootSuite = new Suite("root");
+rootSuite.root = true;
+export function getCurrentSuite() {
+    return unriftGlobalContext.currentSuite || rootSuite;
+}
+export function clearContext() {
+    rootSuite.reset();
+    rootSuite.subtreeHasOnly = false;
+    unriftGlobalContext.currentSuite = rootSuite;
+}

package/dist/esm/test.d.ts

@@ -0,0 +1,18 @@
+import { TaskMode, TaskStatus, type PromisableFn } from "./types";
+interface TestTask {
+    description: string;
+    fn: PromisableFn<void>;
+    run(): Promise<void>;
+}
+export declare class Test implements TestTask {
+    description: string;
+    durationMs: number;
+    error?: Error;
+    fn: PromisableFn<void>;
+    mode: TaskMode;
+    status: TaskStatus;
+    constructor(description: string, fn: PromisableFn<void>, mode?: TaskMode);
+    run(timeoutMs?: number): Promise<void>;
+}
+export {};
+//# sourceMappingURL=test.d.ts.map

package/dist/esm/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../src/test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAElE,UAAU,QAAQ;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,EAAE,EAAE,YAAY,CAAC,IAAI,CAAC,CAAC;IACvB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACtB;AAED,qBAAa,IAAK,YAAW,QAAQ;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAK;IACvB,KAAK,CAAC,EAAE,KAAK,CAAC;IAEd,EAAE,EAAE,YAAY,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,EAAE,QAAQ,CAAC;IAEf,MAAM,EAAE,UAAU,CAAsB;gBAGtC,WAAW,EAAE,MAAM,EACnB,EAAE,EAAE,YAAY,CAAC,IAAI,CAAC,EACtB,IAAI,GAAE,QAA2B;IAO7B,GAAG,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAwC7C"}

package/dist/esm/test.js

@@ -0,0 +1,52 @@
+import { TaskMode, TaskStatus } from "./types.js";
+export class Test {
+    description;
+    durationMs = 0;
+    error;
+    fn;
+    mode;
+    status = TaskStatus.Pending;
+    constructor(description, fn, mode = TaskMode.Default) {
+        this.description = description;
+        this.fn = fn;
+        this.mode = mode;
+    }
+    async run(timeoutMs) {
+        if (this.mode === TaskMode.Skip) {
+            this.status = TaskStatus.Skipped;
+            this.durationMs = 0;
+            return;
+        }
+        const start = performance.now();
+        this.status = TaskStatus.Running;
+        const exec = Promise.resolve().then(() => this.fn());
+        try {
+            if (timeoutMs !== undefined) {
+                let timeoutId = null;
+                const timeoutFn = new Promise((_, reject) => {
+                    timeoutId = setTimeout(() => {
+                        reject(new Error(`Test timed out after ${timeoutMs} ms`));
+                    }, timeoutMs);
+                });
+                try {
+                    await Promise.race([exec, timeoutFn]);
+                }
+                finally {
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                }
+            }
+            else {
+                await exec;
+            }
+            this.status = TaskStatus.Pass;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error : new Error(String(error));
+            this.status = TaskStatus.Fail;
+        }
+        finally {
+            this.durationMs = performance.now() - start;
+        }
+    }
+}

package/dist/esm/types.d.ts

@@ -0,0 +1,24 @@
+type Promisable<T> = Promise<T> | T;
+export type PromisableFn<T> = () => Promisable<T>;
+export declare enum TaskStatus {
+    Pending = "pending",
+    Running = "running",
+    Pass = "pass",
+    Fail = "fail",
+    Only = "only",
+    Skipped = "skipped",
+    Todo = "todo"
+}
+export declare enum TaskMode {
+    Default = "default",
+    Only = "only",
+    Skip = "skip"
+}
+export interface MatcherContext {
+    isNot: boolean;
+    diff(a: unknown, b: unknown): string;
+}
+export type MatcherFn = (this: MatcherContext, received: unknown, ...args: readonly unknown[]) => void | Promise<void>;
+export type MatcherMap = Record<string, MatcherFn>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAEpC,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,MAAM,UAAU,CAAC,CAAC,CAAC,CAAC;AAElD,oBAAY,UAAU;IACpB,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,IAAI,SAAS;IACb,OAAO,YAAY;IACnB,IAAI,SAAS;CACd;AAED,oBAAY,QAAQ;IAClB,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,IAAI,SAAS;CACd;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CACtC;AAED,MAAM,MAAM,SAAS,GAAG,CACtB,IAAI,EAAE,cAAc,EACpB,QAAQ,EAAE,OAAO,EACjB,GAAG,IAAI,EAAE,SAAS,OAAO,EAAE,KACxB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC"}

package/dist/esm/types.js

@@ -0,0 +1,16 @@
+export var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus["Pending"] = "pending";
+    TaskStatus["Running"] = "running";
+    TaskStatus["Pass"] = "pass";
+    TaskStatus["Fail"] = "fail";
+    TaskStatus["Only"] = "only";
+    TaskStatus["Skipped"] = "skipped";
+    TaskStatus["Todo"] = "todo";
+})(TaskStatus || (TaskStatus = {}));
+export var TaskMode;
+(function (TaskMode) {
+    TaskMode["Default"] = "default";
+    TaskMode["Only"] = "only";
+    TaskMode["Skip"] = "skip";
+})(TaskMode || (TaskMode = {}));

package/dist/esm/utils/colors.d.ts

@@ -0,0 +1,7 @@
+export declare const colors: {
+    green: (text: string) => string;
+    red: (text: string) => string;
+    yellow: (text: string) => string;
+    bold: (text: string) => string;
+};
+//# sourceMappingURL=colors.d.ts.map

package/dist/esm/utils/colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../../src/utils/colors.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,MAAM;kBAHH,MAAM;gBAAN,MAAM;mBAAN,MAAM;iBAAN,MAAM;CAQrB,CAAC"}