@rstest/core/dist/globalSetupWorker.js

The Rsbuild-based test tool.

import 'module';
/*#__PURE__*/ import.meta.url;
import { __webpack_require__ } from "./rslib-runtime.js";
import { formatTestError } from "./7913.js";
import "./5693.js";
const source_map_support = __webpack_require__("../../node_modules/.pnpm/source-map-support@0.5.21/node_modules/source-map-support/source-map-support.js");
const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
let teardownCallbacks = [];
let initialEnv = {};
let envChanges = {};
function trackEnvChanges() {
    initialEnv = {
        ...process.env
    };
}
function captureEnvChanges() {
    const changes = {};
    for(const key in process.env)if (process.env[key] !== initialEnv[key]) changes[key] = process.env[key];
    for(const key in initialEnv)if (!(key in process.env) && void 0 !== initialEnv[key]) changes[key] = void 0;
    return changes;
}
const runGlobalSetup = async (data)=>{
    try {
        if (0 === data.entries.length) return {
            success: true,
            hasTeardown: false
        };
        (0, source_map_support.install)({
            environment: 'node',
            handleUncaughtExceptions: false,
            retrieveSourceMap: (source)=>{
                if (data.sourceMaps[source]) return {
                    url: source,
                    map: JSON.parse(data.sourceMaps[source])
                };
                return null;
            }
        });
        trackEnvChanges();
        for (const entry of data.entries){
            const { distPath, testPath } = entry;
            const setupCodeContent = data.assetFiles[distPath];
            const { loadModule } = data.outputModule ? await import("./0~6923.js").then((mod)=>({
                    EsmMode: mod.loadEsModule_EsmMode,
                    asModule: mod.asModule,
                    loadModule: mod.loadModule,
                    updateLatestAssetFiles: mod.updateLatestAssetFiles
                })) : await import("./0~5835.js").then((mod)=>({
                    cacheableLoadModule: mod.cacheableLoadModule,
                    loadModule: mod.loadModule,
                    updateLatestAssetFiles: mod.updateLatestAssetFiles
                }));
            const module = await loadModule({
                codeContent: setupCodeContent,
                distPath,
                testPath,
                rstestContext: {
                    global,
                    console: global.console,
                    Error
                },
                assetFiles: data.assetFiles,
                interopDefault: data.interopDefault
            });
            let teardownCallback;
            if (module && 'object' == typeof module) {
                if (module.setup && 'function' == typeof module.setup) {
                    await module.setup();
                    if (module.teardown && 'function' == typeof module.teardown) teardownCallback = module.teardown;
                } else if (module.default && 'function' == typeof module.default) teardownCallback = await module.default();
            }
            if (teardownCallback) teardownCallbacks.push(teardownCallback);
        }
        envChanges = captureEnvChanges();
        return {
            success: true,
            hasTeardown: teardownCallbacks.length > 0,
            teardownCount: teardownCallbacks.length,
            envChanges: envChanges
        };
    } catch (error) {
        return {
            success: false,
            hasTeardown: false,
            errors: formatTestError(error)
        };
    }
};
async function runInPool(options) {
    switch(options.type){
        case 'setup':
            return runGlobalSetup(options);
        case 'teardown':
            return runGlobalTeardown();
    }
}
const runGlobalTeardown = async ()=>{
    try {
        const callbacks = [
            ...teardownCallbacks
        ];
        teardownCallbacks = [];
        for (const teardown of callbacks.reverse())await teardown();
        return {
            success: true
        };
    } catch (error) {
        const message = error instanceof Error && error.stack ? error.stack : String(error);
        console.error(picocolors_default().red(`Error during global teardown: ${message}`));
        return {
            success: false
        };
    }
};
export default runInPool;
export { runGlobalTeardown };