@rstest/core 0.0.1

package/dist/992.js

@@ -0,0 +1,485 @@
+export const __webpack_ids__ = [
+    "992"
+];
+export const __webpack_modules__ = {
+    "./src/core/rsbuild.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            r: ()=>createRsbuildServer,
+            z: ()=>prepareRsbuild
+        });
+        var external_node_fs_ = __webpack_require__("node:fs");
+        var core_ = __webpack_require__("@rsbuild/core");
+        var external_pathe_ = __webpack_require__("pathe");
+        var utils = __webpack_require__("./src/utils/index.ts");
+        class TestFileWatchPlugin {
+            contextToWatch = null;
+            constructor(contextToWatch){
+                this.contextToWatch = contextToWatch;
+            }
+            apply(compiler) {
+                compiler.hooks.afterCompile.tap('Rstest:TestFileWatchPlugin', (compilation)=>{
+                    if (null === this.contextToWatch) return;
+                    const contextDep = compilation.contextDependencies;
+                    if (!contextDep.has(this.contextToWatch)) contextDep.add(this.contextToWatch);
+                });
+            }
+        }
+        const pluginEntryWatch = ({ isWatch, globTestSourceEntries, setupFiles })=>({
+                name: 'rstest:entry-watch',
+                setup: (api)=>{
+                    api.modifyRspackConfig(async (config)=>{
+                        if (isWatch) {
+                            config.plugins.push(new TestFileWatchPlugin(api.context.rootPath));
+                            config.entry = async ()=>{
+                                const sourceEntries = await globTestSourceEntries();
+                                return {
+                                    ...sourceEntries,
+                                    ...setupFiles
+                                };
+                            };
+                            config.watchOptions ??= {};
+                            config.watchOptions.ignored = (0, utils.XQ)(config.watchOptions.ignored || []);
+                            if (0 === config.watchOptions.ignored.length) config.watchOptions.ignored.push('**/.git', '**/node_modules');
+                            config.watchOptions.ignored.push(utils.f1);
+                        } else {
+                            const sourceEntries = await globTestSourceEntries();
+                            config.entry = {
+                                ...sourceEntries,
+                                ...setupFiles
+                            };
+                        }
+                    });
+                }
+            });
+        class IgnoreModuleNotFoundErrorPlugin {
+            apply(compiler) {
+                compiler.hooks.done.tap('Rstest:IgnoreModuleNotFoundPlugin', (stats)=>{
+                    stats.compilation.errors = stats.compilation.errors.filter((error)=>{
+                        if (/Module not found/.test(error.message)) return false;
+                        return true;
+                    });
+                });
+            }
+        }
+        const pluginIgnoreResolveError = {
+            name: 'rstest:ignore-resolve-error',
+            setup: (api)=>{
+                api.modifyRspackConfig(async (config)=>{
+                    config.plugins.push(new IgnoreModuleNotFoundErrorPlugin());
+                    config.optimization ??= {};
+                    config.optimization.emitOnErrors = true;
+                    config.ignoreWarnings ??= [];
+                    config.ignoreWarnings.push(/Module not found/);
+                });
+            }
+        };
+        const isMultiCompiler = (compiler)=>'compilers' in compiler && Array.isArray(compiler.compilers);
+        const autoExternalNodeModules = ({ context, request, dependencyType, getResolve }, callback)=>{
+            if (!request || request.startsWith('node:')) return callback();
+            if (request.startsWith('@swc/helpers/')) return callback();
+            const doExternal = (externalPath = request)=>{
+                callback(void 0, externalPath, 'commonjs' === dependencyType ? 'commonjs' : 'module-import');
+            };
+            if (/node_modules/.test(request)) return doExternal();
+            const resolver = getResolve?.();
+            if (!resolver) return callback();
+            resolver(context, request, (err, resolvePath)=>{
+                if (err) return callback();
+                if (resolvePath && /node_modules/.test(resolvePath)) return doExternal(resolvePath);
+                return callback();
+            });
+        };
+        const prepareRsbuild = async (context, globTestSourceEntries, setupFiles)=>{
+            const { command, normalizedConfig: { name, plugins, resolve, source, output, tools } } = context;
+            core_.logger.level = (0, utils.L1)() ? 'verbose' : 'error';
+            const writeToDisk = 'true' === process.env.DEBUG_RSTEST_OUTPUTS;
+            const rsbuildInstance = await (0, core_.createRsbuild)({
+                rsbuildConfig: {
+                    tools,
+                    plugins,
+                    resolve,
+                    source,
+                    output,
+                    server: {
+                        printUrls: false,
+                        strictPort: false,
+                        middlewareMode: true
+                    },
+                    environments: {
+                        [name]: {
+                            dev: {
+                                writeToDisk
+                            },
+                            source: {
+                                define: {
+                                    'import.meta.rstest': "global['@rstest/core']",
+                                    'import.meta.dirname': '__dirname',
+                                    'import.meta.filename': '__filename'
+                                }
+                            },
+                            output: {
+                                manifest: true,
+                                sourceMap: {
+                                    js: 'source-map'
+                                },
+                                distPath: {
+                                    root: utils.Nk
+                                },
+                                externals: [
+                                    {
+                                        '@rstest/core': 'global @rstest/core'
+                                    },
+                                    autoExternalNodeModules
+                                ],
+                                target: 'node'
+                            },
+                            tools: {
+                                rspack: (config)=>{
+                                    config.output ??= {};
+                                    config.output.iife = false;
+                                    config.externalsPresets = {
+                                        node: true
+                                    };
+                                    config.output.devtoolModuleFilenameTemplate = '[absolute-resource-path]';
+                                    config.module.parser ??= {};
+                                    config.module.parser.javascript = {
+                                        importDynamic: false,
+                                        requireDynamic: false,
+                                        requireAsExpression: false,
+                                        ...config.module.parser.javascript || {}
+                                    };
+                                    config.optimization = {
+                                        ...config.optimization || {},
+                                        moduleIds: 'named',
+                                        chunkIds: 'named',
+                                        splitChunks: {
+                                            chunks: 'all',
+                                            minSize: 0,
+                                            maxInitialRequests: Number.POSITIVE_INFINITY
+                                        }
+                                    };
+                                }
+                            },
+                            plugins: [
+                                pluginIgnoreResolveError,
+                                pluginEntryWatch({
+                                    globTestSourceEntries,
+                                    setupFiles,
+                                    isWatch: 'watch' === command
+                                })
+                            ]
+                        }
+                    }
+                }
+            });
+            return rsbuildInstance;
+        };
+        const createRsbuildServer = async ({ name, globTestSourceEntries, setupFiles, rsbuildInstance })=>{
+            let rspackCompiler;
+            const rstestCompilerPlugin = {
+                name: 'rstest:compiler',
+                setup: (api)=>{
+                    api.onAfterCreateCompiler(({ compiler })=>{
+                        rspackCompiler = compiler;
+                    });
+                }
+            };
+            rsbuildInstance.addPlugins([
+                rstestCompilerPlugin
+            ]);
+            const devServer = await rsbuildInstance.createDevServer({
+                getPortSilently: true
+            });
+            if ((0, utils.L1)()) await rsbuildInstance.inspectConfig({
+                writeToDisk: true
+            });
+            const outputFileSystem = (isMultiCompiler(rspackCompiler) ? rspackCompiler.compilers[0].outputFileSystem : rspackCompiler.outputFileSystem) || external_node_fs_["default"];
+            const getRsbuildStats = async ()=>{
+                const stats = await devServer.environments[name].getStats();
+                const manifest = devServer.environments[name].context.manifest;
+                const { entrypoints, outputPath, assets, time: buildTime } = stats.toJson({
+                    all: false,
+                    entrypoints: true,
+                    outputPath: true,
+                    assets: true,
+                    relatedAssets: true,
+                    cachedAssets: true,
+                    timings: true
+                });
+                const readFile = async (fileName)=>new Promise((resolve, reject)=>{
+                        outputFileSystem.readFile(fileName, (err, data)=>{
+                            if (err) reject(err);
+                            resolve('string' == typeof data ? data : data.toString());
+                        });
+                    });
+                const getEntryFiles = async ()=>{
+                    const entryFiles = {};
+                    const entries = Object.keys(manifest.entries);
+                    for (const entry of entries){
+                        const data = manifest.entries[entry];
+                        entryFiles[entry] = ((data?.initial?.js || []).concat(data?.async?.js || []) || []).map((file)=>external_pathe_["default"].join(outputPath, file));
+                    }
+                    return entryFiles;
+                };
+                const entryFiles = await getEntryFiles();
+                const entries = [];
+                const setupEntries = [];
+                const sourceEntries = await globTestSourceEntries();
+                for (const entry of Object.keys(entrypoints)){
+                    const e = entrypoints[entry];
+                    const distPath = external_pathe_["default"].join(outputPath, e.assets[e.assets.length - 1].name);
+                    if (setupFiles[entry]) setupEntries.push({
+                        distPath,
+                        testPath: setupFiles[entry],
+                        files: entryFiles[entry]
+                    });
+                    else if (sourceEntries[entry]) entries.push({
+                        distPath,
+                        testPath: sourceEntries[entry],
+                        files: entryFiles[entry]
+                    });
+                }
+                const sourceMaps = Object.fromEntries((await Promise.all(assets.map(async (asset)=>{
+                    const sourceMapPath = asset?.info.related?.sourceMap?.[0];
+                    const assetFilePath = external_pathe_["default"].join(outputPath, asset.name);
+                    if (sourceMapPath) {
+                        const filePath = external_pathe_["default"].join(outputPath, sourceMapPath);
+                        const sourceMap = await readFile(filePath);
+                        return [
+                            assetFilePath,
+                            JSON.parse(sourceMap)
+                        ];
+                    }
+                    return [
+                        assetFilePath,
+                        null
+                    ];
+                }))).filter((asset)=>null !== asset[1]));
+                return {
+                    entries,
+                    setupEntries,
+                    buildTime: buildTime,
+                    assetFiles: Object.fromEntries(await Promise.all(assets.map(async (a)=>{
+                        const filePath = external_pathe_["default"].join(outputPath, a.name);
+                        return [
+                            filePath,
+                            await readFile(filePath)
+                        ];
+                    }))),
+                    sourceMaps,
+                    getSourcemap: (sourcePath)=>sourceMaps[sourcePath] || null,
+                    close: devServer.close
+                };
+            };
+            return getRsbuildStats;
+        };
+    },
+    "./src/pool/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            K: ()=>createPool
+        });
+        var external_node_os_ = __webpack_require__("node:os");
+        var utils = __webpack_require__("./src/utils/index.ts");
+        var external_node_events_ = __webpack_require__("node:events");
+        var external_node_url_ = __webpack_require__("node:url");
+        var external_node_v8_ = __webpack_require__("node:v8");
+        var external_birpc_ = __webpack_require__("birpc");
+        var external_pathe_ = __webpack_require__("pathe");
+        var external_tinypool_ = __webpack_require__("tinypool");
+        const forks_filename = (0, external_node_url_.fileURLToPath)(import.meta.url);
+        const forks_dirname = (0, external_pathe_.dirname)(forks_filename);
+        function createChannel(rpcMethods) {
+            const emitter = new external_node_events_["default"]();
+            const cleanup = ()=>emitter.removeAllListeners();
+            const events = {
+                message: 'message',
+                response: 'response'
+            };
+            const channel = {
+                onMessage: (callback)=>{
+                    emitter.on(events.message, callback);
+                },
+                postMessage: (message)=>{
+                    emitter.emit(events.response, message);
+                }
+            };
+            (0, external_birpc_.createBirpc)(rpcMethods, {
+                serialize: external_node_v8_["default"].serialize,
+                deserialize: (v)=>external_node_v8_["default"].deserialize(Buffer.from(v)),
+                post (v) {
+                    emitter.emit(events.message, v);
+                },
+                on (fn) {
+                    emitter.on(events.response, fn);
+                }
+            });
+            return {
+                channel,
+                cleanup
+            };
+        }
+        const createForksPool = (poolOptions)=>{
+            const { maxWorkers: maxThreads, minWorkers: minThreads, env, execArgv = [], isolate = true } = poolOptions;
+            const options = {
+                runtime: 'child_process',
+                filename: (0, external_pathe_.resolve)(forks_dirname, './worker.js'),
+                env,
+                execArgv,
+                maxThreads,
+                minThreads,
+                concurrentTasksPerWorker: 1,
+                isolateWorkers: isolate
+            };
+            const pool = new external_tinypool_.Tinypool(options);
+            return {
+                name: 'forks',
+                runTest: async ({ options, rpcMethods })=>{
+                    const { channel, cleanup } = createChannel(rpcMethods);
+                    try {
+                        return await pool.run(options, {
+                            channel
+                        });
+                    } finally{
+                        cleanup();
+                    }
+                },
+                collectTests: async ({ options, rpcMethods })=>{
+                    const { channel, cleanup } = createChannel(rpcMethods);
+                    try {
+                        return await pool.run(options, {
+                            channel
+                        });
+                    } finally{
+                        cleanup();
+                    }
+                },
+                close: ()=>pool.destroy()
+            };
+        };
+        const getNumCpus = ()=>external_node_os_["default"].availableParallelism?.() ?? external_node_os_["default"].cpus().length;
+        const parseWorkers = (maxWorkers)=>{
+            const parsed = Number.parseInt(maxWorkers.toString(), 10);
+            if ('string' == typeof maxWorkers && maxWorkers.trim().endsWith('%')) {
+                const numCpus = getNumCpus();
+                const workers = Math.floor(parsed / 100 * numCpus);
+                return Math.max(workers, 1);
+            }
+            return parsed > 0 ? parsed : 1;
+        };
+        const createPool = async ({ entries, context, assetFiles, setupEntries, sourceMaps })=>{
+            const execArgv = process.execArgv.filter((execArg)=>execArg.startsWith('--perf') || execArg.startsWith('--cpu-prof') || execArg.startsWith('--heap-prof') || execArg.startsWith('--diagnostic-dir'));
+            const numCpus = getNumCpus();
+            const { normalizedConfig: { pool: poolOptions, isolate }, reporters } = context;
+            const threadsCount = 'watch' === context.command ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
+            const maxWorkers = poolOptions.maxWorkers ? parseWorkers(poolOptions.maxWorkers) : threadsCount;
+            const minWorkers = poolOptions.minWorkers ? parseWorkers(poolOptions.minWorkers) : maxWorkers < threadsCount ? maxWorkers : threadsCount;
+            if (maxWorkers < minWorkers) throw `Invalid pool configuration: maxWorkers(${maxWorkers}) cannot be less than minWorkers(${minWorkers}).`;
+            const pool = createForksPool({
+                ...poolOptions,
+                isolate,
+                maxWorkers,
+                minWorkers,
+                execArgv: [
+                    ...poolOptions?.execArgv ?? [],
+                    ...execArgv,
+                    '--experimental-vm-modules',
+                    '--experimental-import-meta-resolve'
+                ],
+                env: {
+                    NODE_ENV: 'test',
+                    FORCE_COLOR: '1',
+                    ...process.env
+                }
+            });
+            const { updateSnapshot } = context.snapshotManager.options;
+            const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment } = context.normalizedConfig;
+            const runtimeConfig = {
+                testNamePattern,
+                testTimeout,
+                passWithNoTests,
+                retry,
+                globals,
+                clearMocks,
+                resetMocks,
+                restoreMocks,
+                unstubEnvs,
+                unstubGlobals,
+                maxConcurrency,
+                printConsoleTrace,
+                disableConsoleIntercept,
+                testEnvironment
+            };
+            const rpcMethods = {
+                onTestCaseResult: async (result)=>{
+                    await Promise.all(reporters.map((reporter)=>reporter.onTestCaseResult?.(result)));
+                },
+                onConsoleLog: async (log)=>{
+                    await Promise.all(reporters.map((reporter)=>reporter.onUserConsoleLog?.(log)));
+                },
+                onTestFileStart: async (test)=>{
+                    await Promise.all(reporters.map((reporter)=>reporter.onTestFileStart?.(test)));
+                },
+                onTestFileResult: async (test)=>{
+                    await Promise.all(reporters.map((reporter)=>reporter.onTestFileResult?.(test)));
+                }
+            };
+            const setupAssets = setupEntries.flatMap((entry)=>entry.files);
+            const entryLength = Object.keys(entries).length;
+            const filterAssetsByEntry = (entryInfo)=>{
+                const neededFiles = entryLength > 1 && entryInfo.files ? Object.fromEntries(Object.entries(assetFiles).filter(([key])=>entryInfo.files.includes(key) || setupAssets.includes(key))) : assetFiles;
+                const neededSourceMaps = entryLength > 1 ? Object.fromEntries(Object.entries(sourceMaps).filter(([key])=>neededFiles[key])) : sourceMaps;
+                return {
+                    assetFiles: neededFiles,
+                    sourceMaps: neededSourceMaps
+                };
+            };
+            return {
+                runTests: async ()=>{
+                    const results = await Promise.all(entries.map((entryInfo)=>{
+                        const { assetFiles, sourceMaps } = filterAssetsByEntry(entryInfo);
+                        return pool.runTest({
+                            options: {
+                                entryInfo,
+                                assetFiles,
+                                context: {
+                                    rootPath: context.rootPath,
+                                    runtimeConfig: (0, utils.v8)(runtimeConfig)
+                                },
+                                type: 'run',
+                                sourceMaps,
+                                setupEntries,
+                                updateSnapshot
+                            },
+                            rpcMethods
+                        });
+                    }));
+                    for (const result of results)if (result.snapshotResult) context.snapshotManager.add(result.snapshotResult);
+                    const testResults = results.flatMap((r)=>r.results);
+                    return {
+                        results,
+                        testResults
+                    };
+                },
+                collectTests: async ()=>Promise.all(entries.map((entryInfo)=>{
+                        const { assetFiles, sourceMaps } = filterAssetsByEntry(entryInfo);
+                        return pool.collectTests({
+                            options: {
+                                entryInfo,
+                                assetFiles,
+                                context: {
+                                    rootPath: context.rootPath,
+                                    runtimeConfig: (0, utils.v8)(runtimeConfig)
+                                },
+                                type: 'collect',
+                                sourceMaps,
+                                setupEntries,
+                                updateSnapshot
+                            },
+                            rpcMethods
+                        });
+                    })),
+                close: ()=>pool.close()
+            };
+        };
+    }
+};