allure-vitest/dist/runner.js

Allure Vitest integration

var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _ConcurrencyAwareAllureVitestRunner_releaseNonRunnableTask, _ConcurrencyAwareAllureVitestRunner_releaseTask, _ConcurrencyAwareAllureVitestRunner_releaseDynamicallySkippedTask;
import * as vitest from "vitest";
import { getAsyncContext } from "./concurrentState.js";
const resolveRunnerBaseClass = async () => {
    const customRunnerModulePath = vitest.inject("__allure_vitest_custom_runner_module__");
    if (customRunnerModulePath) {
        // The value comes from config.runner, which is always resolved to an absolute
        // or bare specifier
        const customRunnerCtor = (await import(customRunnerModulePath)).default;
        if (!customRunnerCtor && typeof customRunnerCtor !== "function") {
            throw new Error(`Runner must export a default function, but got ${typeof customRunnerCtor} imported from ${customRunnerModulePath}`);
        }
        return customRunnerCtor;
    }
    if ("TestRunner" in vitest) {
        // Vitest 4.1+
        return vitest.TestRunner;
    }
    // Vitest <=4.0
    const { VitestTestRunner } = await import("vitest/runners");
    return VitestTestRunner;
};
class ConcurrencyAwareAllureVitestRunner extends (await resolveRunnerBaseClass()) {
    constructor(config) {
        super(config);
        _ConcurrencyAwareAllureVitestRunner_releaseNonRunnableTask.set(this, (test) => {
            if (test.mode !== "run" && test.mode !== "queued") {
                __classPrivateFieldGet(this, _ConcurrencyAwareAllureVitestRunner_releaseTask, "f").call(this, test);
            }
        });
        _ConcurrencyAwareAllureVitestRunner_releaseTask.set(this, (test) => {
            getAsyncContext().activeTasks.delete(test);
        });
        _ConcurrencyAwareAllureVitestRunner_releaseDynamicallySkippedTask.set(this, (test) => {
            const result = test.result;
            if (result?.pending || result?.state === "skip") {
                __classPrivateFieldGet(this, _ConcurrencyAwareAllureVitestRunner_releaseTask, "f").call(this, test);
            }
        });
        this.onBeforeRunTask = async (test) => {
            const asyncContext = getAsyncContext();
            asyncContext.activeTasks.add(test);
            asyncContext.currentTaskStorage.enterWith(test);
            await super.onBeforeRunTask?.(test);
            __classPrivateFieldGet(this, _ConcurrencyAwareAllureVitestRunner_releaseNonRunnableTask, "f").call(this, test);
        };
        this.onAfterRetryTask = (test, options) => {
            try {
                return super.onAfterRetryTask?.(test, options);
            }
            finally {
                __classPrivateFieldGet(this, _ConcurrencyAwareAllureVitestRunner_releaseDynamicallySkippedTask, "f").call(this, test);
            }
        };
        this.onAfterRunTask = async (test) => {
            try {
                return await super.onAfterRunTask?.(test);
            }
            finally {
                __classPrivateFieldGet(this, _ConcurrencyAwareAllureVitestRunner_releaseTask, "f").call(this, test);
            }
        };
    }
}
_ConcurrencyAwareAllureVitestRunner_releaseNonRunnableTask = new WeakMap(), _ConcurrencyAwareAllureVitestRunner_releaseTask = new WeakMap(), _ConcurrencyAwareAllureVitestRunner_releaseDynamicallySkippedTask = new WeakMap();
export default ConcurrencyAwareAllureVitestRunner;
//# sourceMappingURL=runner.js.map