@rstest/core 0.2.1 → 0.3.0

package/dist/{359.js → 12.js}

@@ -1,12 +1,13 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
+export const __webpack_id__ = "12";
 export const __webpack_ids__ = [
-    "359"
+    "12"
 ];
 export const __webpack_modules__ = {
     "../../node_modules/.pnpm/stacktrace-parser@0.1.11/node_modules/stacktrace-parser/dist/stack-trace-parser.esm.js": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
-            Q: ()=>parse
+            q: ()=>parse
         });
         var UNKNOWN_FUNCTION = '<unknown>';
         function parse(stackString) {
@@ -300,7 +301,7 @@ export const __webpack_modules__ = {
                 const summary = [];
                 for (const module of this.runningModules){
                     const relativePath = (0, external_pathe_.relative)(this.rootPath, module);
-                    summary.push(`${utils.$_.bgYellow(utils.$_.bold(' RUNS '))} ${(0, utils.aj)(relativePath)}`);
+                    summary.push(`${utils.yW.bgYellow(utils.yW.bold(' RUNS '))} ${(0, utils.EQ)(relativePath)}`);
                 }
                 summary.push('');
                 return summary;
@@ -319,70 +320,70 @@ export const __webpack_modules__ = {
             }
         }
         const getSummaryStatusString = (tasks, name = 'tests', showTotal = true)=>{
-            if (0 === tasks.length) return utils.$_.dim(`no ${name}`);
+            if (0 === tasks.length) return utils.yW.dim(`no ${name}`);
             const passed = tasks.filter((result)=>'pass' === result.status);
             const failed = tasks.filter((result)=>'fail' === result.status);
             const skipped = tasks.filter((result)=>'skip' === result.status);
             const todo = tasks.filter((result)=>'todo' === result.status);
             const status = [
-                failed.length ? utils.$_.bold(utils.$_.red(`${failed.length} failed`)) : null,
-                passed.length ? utils.$_.bold(utils.$_.green(`${passed.length} passed`)) : null,
-                skipped.length ? utils.$_.yellow(`${skipped.length} skipped`) : null,
-                todo.length ? utils.$_.gray(`${todo.length} todo`) : null
+                failed.length ? utils.yW.bold(utils.yW.red(`${failed.length} failed`)) : null,
+                passed.length ? utils.yW.bold(utils.yW.green(`${passed.length} passed`)) : null,
+                skipped.length ? utils.yW.yellow(`${skipped.length} skipped`) : null,
+                todo.length ? utils.yW.gray(`${todo.length} todo`) : null
             ].filter(Boolean);
-            return status.join(utils.$_.dim(' | ')) + (showTotal && status.length > 1 ? utils.$_.gray(` (${tasks.length})`) : '');
+            return status.join(utils.yW.dim(' | ')) + (showTotal && status.length > 1 ? utils.yW.gray(` (${tasks.length})`) : '');
         };
         const printSnapshotSummaryLog = (snapshots, rootDir)=>{
             const summary = [];
-            if (snapshots.added) summary.push(utils.$_.bold(utils.$_.green(`${snapshots.added} written`)));
-            if (snapshots.unmatched) summary.push(utils.$_.bold(utils.$_.red(`${snapshots.unmatched} failed`)));
-            if (snapshots.updated) summary.push(utils.$_.bold(utils.$_.green(`${snapshots.updated} updated `)));
-            if (snapshots.filesRemoved) if (snapshots.didUpdate) summary.push(utils.$_.bold(utils.$_.green(`${snapshots.filesRemoved} files removed `)));
-            else summary.push(utils.$_.bold(utils.$_.yellow(`${snapshots.filesRemoved} files obsolete `)));
+            if (snapshots.added) summary.push(utils.yW.bold(utils.yW.green(`${snapshots.added} written`)));
+            if (snapshots.unmatched) summary.push(utils.yW.bold(utils.yW.red(`${snapshots.unmatched} failed`)));
+            if (snapshots.updated) summary.push(utils.yW.bold(utils.yW.green(`${snapshots.updated} updated `)));
+            if (snapshots.filesRemoved) if (snapshots.didUpdate) summary.push(utils.yW.bold(utils.yW.green(`${snapshots.filesRemoved} files removed `)));
+            else summary.push(utils.yW.bold(utils.yW.yellow(`${snapshots.filesRemoved} files obsolete `)));
             const POINTER = "\u279C";
             if (snapshots.filesRemovedList?.length) {
                 const [head, ...tail] = snapshots.filesRemovedList;
-                summary.push(`${utils.$_.gray(POINTER)} ${(0, utils.Ps)(rootDir, head)}`);
-                for (const key of tail)summary.push(`  ${(0, utils.Ps)(rootDir, key)}`);
+                summary.push(`${utils.yW.gray(POINTER)} ${(0, utils.XJ)(rootDir, head)}`);
+                for (const key of tail)summary.push(`  ${(0, utils.XJ)(rootDir, key)}`);
             }
             if (snapshots.unchecked) {
-                if (snapshots.didUpdate) summary.push(utils.$_.bold(utils.$_.green(`${snapshots.unchecked} removed`)));
-                else summary.push(utils.$_.bold(utils.$_.yellow(`${snapshots.unchecked} obsolete`)));
+                if (snapshots.didUpdate) summary.push(utils.yW.bold(utils.yW.green(`${snapshots.unchecked} removed`)));
+                else summary.push(utils.yW.bold(utils.yW.yellow(`${snapshots.unchecked} obsolete`)));
                 for (const uncheckedFile of snapshots.uncheckedKeysByFile){
-                    summary.push(`${utils.$_.gray(POINTER)} ${(0, utils.Ps)(rootDir, uncheckedFile.filePath)}`);
+                    summary.push(`${utils.yW.gray(POINTER)} ${(0, utils.XJ)(rootDir, uncheckedFile.filePath)}`);
                     for (const key of uncheckedFile.keys)summary.push(`  ${key}`);
                 }
             }
             for (const [index, snapshot] of summary.entries()){
                 const title = 0 === index ? 'Snapshots' : '';
-                utils.kg.log(`${utils.$_.gray(title.padStart(12))} ${snapshot}`);
+                utils.vF.log(`${utils.yW.gray(title.padStart(12))} ${snapshot}`);
             }
         };
         const printSummaryLog = ({ results, testResults, snapshotSummary, duration, rootPath })=>{
-            utils.kg.log('');
+            utils.vF.log('');
             printSnapshotSummaryLog(snapshotSummary, rootPath);
-            utils.kg.log(`${utils.$_.gray('Test Files'.padStart(11))} ${getSummaryStatusString(results)}`);
-            utils.kg.log(`${utils.$_.gray('Tests'.padStart(11))} ${getSummaryStatusString(testResults)}`);
-            utils.kg.log(`${utils.$_.gray('Duration'.padStart(11))} ${(0, utils.AS)(duration.totalTime)} ${utils.$_.gray(`(build ${(0, utils.AS)(duration.buildTime)}, tests ${(0, utils.AS)(duration.testTime)})`)}`);
-            utils.kg.log('');
+            utils.vF.log(`${utils.yW.gray('Test Files'.padStart(11))} ${getSummaryStatusString(results)}`);
+            utils.vF.log(`${utils.yW.gray('Tests'.padStart(11))} ${getSummaryStatusString(testResults)}`);
+            utils.vF.log(`${utils.yW.gray('Duration'.padStart(11))} ${(0, utils.kV)(duration.totalTime)} ${utils.yW.gray(`(build ${(0, utils.kV)(duration.buildTime)}, tests ${(0, utils.kV)(duration.testTime)})`)}`);
+            utils.vF.log('');
         };
-        const printSummaryErrorLogs = async ({ testResults, results, rootPath, getSourcemap })=>{
+        const printSummaryErrorLogs = async ({ testResults, results, rootPath, getSourcemap, filterRerunTestPaths })=>{
             const failedTests = [
-                ...results.filter((i)=>'fail' === i.status && i.errors?.length),
-                ...testResults.filter((i)=>'fail' === i.status)
+                ...results.filter((i)=>'fail' === i.status && i.errors?.length && (filterRerunTestPaths ? filterRerunTestPaths.includes(i.testPath) : true)),
+                ...testResults.filter((i)=>'fail' === i.status && (filterRerunTestPaths ? filterRerunTestPaths.includes(i.testPath) : true))
             ];
             if (0 === failedTests.length) return;
-            utils.kg.log('');
-            utils.kg.log(utils.$_.bold('Summary of all failing tests:'));
-            utils.kg.log('');
+            utils.vF.log('');
+            utils.vF.log(utils.yW.bold('Summary of all failing tests:'));
+            utils.vF.log('');
             for (const test of failedTests){
                 const relativePath = external_pathe_["default"].relative(rootPath, test.testPath);
-                const nameStr = (0, utils.Yz)(test);
-                utils.kg.log(`${utils.$_.bgRed(' FAIL ')} ${(0, utils.aj)(relativePath)} ${nameStr.length ? `${utils.$_.dim(utils.Qd)} ${nameStr}` : ''}`);
+                const nameStr = (0, utils.fN)(test);
+                utils.vF.log(`${utils.yW.bgRed(' FAIL ')} ${(0, utils.EQ)(relativePath)} ${nameStr.length ? `${utils.yW.dim(utils.vO)} ${nameStr}` : ''}`);
                 if (test.errors) {
                     const { printError } = await Promise.all([
-                        __webpack_require__.e("723"),
-                        __webpack_require__.e("355")
+                        __webpack_require__.e("829"),
+                        __webpack_require__.e("704")
                     ]).then(__webpack_require__.bind(__webpack_require__, "./src/utils/error.ts"));
                     for (const error of test.errors)await printError(error, getSourcemap, rootPath);
                 }
@@ -395,27 +396,27 @@ export const __webpack_modules__ = {
             skip: '-'
         };
         const statusColorfulStr = {
-            fail: utils.$_.red(statusStr.fail),
-            pass: utils.$_.green(statusStr.pass),
-            todo: utils.$_.gray(statusStr.todo),
-            skip: utils.$_.gray(statusStr.skip)
+            fail: utils.yW.red(statusStr.fail),
+            pass: utils.yW.green(statusStr.pass),
+            todo: utils.yW.gray(statusStr.todo),
+            skip: utils.yW.gray(statusStr.skip)
         };
         const logCase = (result, slowTestThreshold)=>{
             const isSlowCase = (result.duration || 0) > slowTestThreshold;
-            const icon = isSlowCase && 'pass' === result.status ? utils.$_.yellow(statusStr[result.status]) : statusColorfulStr[result.status];
-            const nameStr = (0, utils.Yz)(result);
-            const duration = void 0 !== result.duration ? ` (${(0, utils.AS)(result.duration)})` : '';
-            const retry = result.retryCount ? utils.$_.yellow(` (retry x${result.retryCount})`) : '';
-            utils.kg.log(`  ${icon} ${nameStr}${utils.$_.gray(duration)}${retry}`);
-            if (result.errors) for (const error of result.errors)console.error(utils.$_.red(`    ${error.message}`));
+            const icon = isSlowCase && 'pass' === result.status ? utils.yW.yellow(statusStr[result.status]) : statusColorfulStr[result.status];
+            const nameStr = (0, utils.fN)(result);
+            const duration = void 0 !== result.duration ? ` (${(0, utils.kV)(result.duration)})` : '';
+            const retry = result.retryCount ? utils.yW.yellow(` (retry x${result.retryCount})`) : '';
+            utils.vF.log(`  ${icon} ${nameStr}${utils.yW.gray(duration)}${retry}`);
+            if (result.errors) for (const error of result.errors)console.error(utils.yW.red(`    ${error.message}`));
         };
         const logFileTitle = (test, relativePath, slowTestThreshold, alwaysShowTime = false)=>{
-            let title = ` ${utils.$_.bold(statusColorfulStr[test.status])} ${(0, utils.aj)(relativePath)}`;
-            const formatDuration = (duration)=>utils.$_[duration > slowTestThreshold ? 'yellow' : 'green']((0, utils.AS)(duration));
-            title += ` ${utils.$_.gray(`(${test.results.length})`)}`;
+            let title = ` ${utils.yW.bold(statusColorfulStr[test.status])} ${(0, utils.EQ)(relativePath)}`;
+            const formatDuration = (duration)=>utils.yW[duration > slowTestThreshold ? 'yellow' : 'green']((0, utils.kV)(duration));
+            title += ` ${utils.yW.gray(`(${test.results.length})`)}`;
             const isTooSlow = test.duration && test.duration > slowTestThreshold;
             if (alwaysShowTime || isTooSlow) title += ` ${formatDuration(test.duration)}`;
-            utils.kg.log(title);
+            utils.vF.log(title);
         };
         class DefaultReporter {
             rootPath;
@@ -455,26 +456,27 @@ export const __webpack_modules__ = {
                 ];
                 const testPath = (0, external_pathe_.relative)(this.rootPath, log.testPath);
                 if (log.trace) {
-                    const [frame] = (0, stack_trace_parser_esm.Q)(log.trace);
+                    const [frame] = (0, stack_trace_parser_esm.q)(log.trace);
                     const filePath = (0, external_pathe_.relative)(this.rootPath, frame.file || '');
-                    if (filePath !== testPath) titles.push((0, utils.aj)(testPath));
-                    titles.push((0, utils.aj)(filePath) + utils.$_.gray(`:${frame.lineNumber}:${frame.column}`));
-                } else titles.push((0, utils.aj)(testPath));
-                utils.kg.log(titles.join(utils.$_.gray(' | ')));
-                utils.kg.log(log.content);
-                utils.kg.log('');
+                    if (filePath !== testPath) titles.push((0, utils.EQ)(testPath));
+                    titles.push((0, utils.EQ)(filePath) + utils.yW.gray(`:${frame.lineNumber}:${frame.column}`));
+                } else titles.push((0, utils.EQ)(testPath));
+                utils.vF.log(titles.join(utils.yW.gray(' | ')));
+                utils.vF.log(log.content);
+                utils.vF.log('');
             }
             async onExit() {
                 this.statusRenderer?.clear();
             }
-            async onTestRunEnd({ results, testResults, duration, getSourcemap, snapshotSummary }) {
+            async onTestRunEnd({ results, testResults, duration, getSourcemap, snapshotSummary, filterRerunTestPaths }) {
                 this.statusRenderer?.clear();
                 if (false === this.options.summary) return;
                 await printSummaryErrorLogs({
                     testResults,
                     results,
                     rootPath: this.rootPath,
-                    getSourcemap
+                    getSourcemap,
+                    filterRerunTestPaths
                 });
                 printSummaryLog({
                     results,
@@ -492,6 +494,9 @@ export const __webpack_modules__ = {
                 this.onWritePath = options.onWritePath;
                 this.rootPath = rootPath;
             }
+            log(message) {
+                console.log(`${message}\n`);
+            }
             async onTestRunEnd({ results, testResults, getSourcemap }) {
                 const failedTests = [
                     ...results.filter((i)=>'fail' === i.status && i.errors?.length),
@@ -499,14 +504,15 @@ export const __webpack_modules__ = {
                 ];
                 if (0 === failedTests.length) return;
                 const { parseErrorStacktrace } = await Promise.all([
-                    __webpack_require__.e("723"),
-                    __webpack_require__.e("355")
+                    __webpack_require__.e("829"),
+                    __webpack_require__.e("704")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./src/utils/error.ts"));
+                const logs = [];
                 for (const test of failedTests){
                     const { testPath } = test;
-                    const nameStr = (0, utils.Yz)(test);
+                    const nameStr = (0, utils.fN)(test);
                     const shortPath = (0, external_pathe_.relative)(this.rootPath, testPath);
-                    const title = `${shortPath} ${utils.Qd} ${nameStr}`;
+                    const title = `${shortPath} ${utils.vO} ${nameStr}`;
                     for (const error of test.errors || []){
                         let file = testPath;
                         let line = 1;
@@ -525,9 +531,12 @@ export const __webpack_modules__ = {
                                 column = stackFrames[0].column || 1;
                             }
                         }
-                        utils.kg.log(`::${type} file=${this.onWritePath?.(file) || file},line=${line},col=${column},title=${escapeData(title)}::${escapeData(message)}`);
+                        logs.push(`::${type} file=${this.onWritePath?.(file) || file},line=${line},col=${column},title=${escapeData(title)}::${escapeData(message)}`);
                     }
                 }
+                this.log('::group::error for github actions');
+                for (const log of logs)this.log(log);
+                this.log('::endgroup::');
             }
         }
         function escapeData(s) {
@@ -543,13 +552,88 @@ export const __webpack_modules__ = {
             }
         }
         var helper = __webpack_require__("./src/utils/helper.ts");
+        function formatEnvironmentName(name) {
+            return name.replace(/[^a-zA-Z0-9\-_$]/g, '_');
+        }
+        class Rstest {
+            cwd;
+            command;
+            fileFilters;
+            configFilePath;
+            reporters;
+            snapshotManager;
+            version;
+            rootPath;
+            originalConfig;
+            normalizedConfig;
+            idMap = new Map();
+            reporterResults = {
+                results: [],
+                testResults: []
+            };
+            projects = [];
+            constructor({ cwd = process.cwd(), command, fileFilters, configFilePath, projects }, userConfig){
+                this.cwd = cwd;
+                this.command = command;
+                this.fileFilters = fileFilters;
+                this.configFilePath = configFilePath;
+                const rootPath = userConfig.root ? (0, helper.FI)(cwd, userConfig.root) : cwd;
+                const rstestConfig = (0, src_config.wX)(userConfig);
+                const reporters = 'list' !== command ? createReporters(rstestConfig.reporters, {
+                    rootPath,
+                    config: rstestConfig
+                }) : [];
+                const snapshotManager = new SnapshotManager({
+                    updateSnapshot: rstestConfig.update ? 'all' : external_std_env_.isCI ? 'none' : 'new'
+                });
+                this.reporters = reporters;
+                this.snapshotManager = snapshotManager;
+                this.version = "0.3.0";
+                this.rootPath = rootPath;
+                this.originalConfig = userConfig;
+                this.normalizedConfig = rstestConfig;
+                this.projects = projects.length ? projects.map((project)=>{
+                    const config = (0, src_config.wX)(project.config);
+                    return {
+                        configFilePath: project.configFilePath,
+                        rootPath: config.root,
+                        name: config.name,
+                        environmentName: formatEnvironmentName(config.name),
+                        normalizedConfig: config
+                    };
+                }) : [
+                    {
+                        configFilePath,
+                        rootPath,
+                        name: rstestConfig.name,
+                        environmentName: formatEnvironmentName(rstestConfig.name),
+                        normalizedConfig: rstestConfig
+                    }
+                ];
+            }
+            updateReporterResultState(results, testResults, deletedEntries = []) {
+                results.forEach((item)=>{
+                    const existingIndex = this.reporterResults.results.findIndex((r)=>r.testPath === item.testPath);
+                    if (-1 !== existingIndex) this.reporterResults.results[existingIndex] = item;
+                    else this.reporterResults.results.push(item);
+                });
+                const testPathsToUpdate = new Set(testResults.map((r)=>r.testPath));
+                this.reporterResults.testResults = this.reporterResults.testResults.filter((r)=>!testPathsToUpdate.has(r.testPath));
+                this.reporterResults.testResults.push(...testResults);
+                if (deletedEntries.length > 0) {
+                    const deletedPathsSet = new Set(deletedEntries);
+                    this.reporterResults.results = this.reporterResults.results.filter((r)=>!deletedPathsSet.has(r.testPath));
+                    this.reporterResults.testResults = this.reporterResults.testResults.filter((r)=>!deletedPathsSet.has(r.testPath));
+                }
+            }
+        }
         const reportersMap = {
             default: DefaultReporter,
             verbose: VerboseReporter,
             'github-actions': GithubActionsReporter
         };
         function createReporters(reporters, initOptions = {}) {
-            const result = (0, helper.XQ)(reporters).map((reporter)=>{
+            const result = (0, helper.bg)(reporters).map((reporter)=>{
                 if ('string' == typeof reporter || Array.isArray(reporter)) {
                     const [name, options = {}] = 'string' == typeof reporter ? [
                         reporter,
@@ -568,47 +652,25 @@ export const __webpack_modules__ = {
             });
             return result;
         }
-        function createContext(options, userConfig) {
-            const { cwd, command, fileFilters, configFilePath } = options;
-            const rootPath = userConfig.root ? (0, helper.ZY)(cwd, userConfig.root) : cwd;
-            const rstestConfig = (0, src_config.hY)(userConfig);
-            const reporters = 'list' !== command ? createReporters(rstestConfig.reporters, {
-                rootPath,
-                config: rstestConfig
-            }) : [];
-            const snapshotManager = new SnapshotManager({
-                updateSnapshot: rstestConfig.update ? 'all' : external_std_env_.isCI ? 'none' : 'new'
-            });
-            return {
-                configFilePath,
-                command,
-                version: "0.2.1",
-                rootPath,
-                reporters,
-                fileFilters,
-                snapshotManager,
-                originalConfig: userConfig,
-                normalizedConfig: rstestConfig
-            };
-        }
-        function createRstest({ config, configFilePath }, command, fileFilters) {
-            const context = createContext({
+        function createRstest({ config, projects, configFilePath }, command, fileFilters) {
+            const context = new Rstest({
                 cwd: process.cwd(),
                 command,
                 fileFilters,
-                configFilePath
+                configFilePath,
+                projects
             }, config);
             const runTests = async ()=>{
                 const { runTests } = await Promise.all([
-                    __webpack_require__.e("854"),
-                    __webpack_require__.e("920")
+                    __webpack_require__.e("985"),
+                    __webpack_require__.e("33")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./src/core/runTests.ts"));
                 await runTests(context);
             };
             const listTests = async (options)=>{
                 const { listTests } = await Promise.all([
-                    __webpack_require__.e("854"),
-                    __webpack_require__.e("285")
+                    __webpack_require__.e("985"),
+                    __webpack_require__.e("971")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./src/core/listTests.ts"));
                 await listTests(context, options);
             };

package/dist/{72.js → 171.js}

@@ -1,7 +1,8 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
+export const __webpack_id__ = "171";
 export const __webpack_ids__ = [
-    "72"
+    "171"
 ];
 export const __webpack_modules__ = {
     "../../node_modules/.pnpm/js-tokens@4.0.0/node_modules/js-tokens/index.js": function(__unused_webpack_module, exports) {

package/dist/223.js

@@ -0,0 +1,135 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+export const __webpack_id__ = "223";
+export const __webpack_ids__ = [
+    "223"
+];
+export const __webpack_modules__ = {
+    "./src/cli/init.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            initCli: ()=>initCli
+        });
+        var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("node:fs");
+        var pathe__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("pathe");
+        var tinyglobby__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("../../node_modules/.pnpm/tinyglobby@0.2.14/node_modules/tinyglobby/dist/index.mjs");
+        var _config__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./src/config.ts");
+        var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./src/utils/index.ts");
+        async function resolveConfig(options) {
+            const { content: config, filePath: configFilePath } = await (0, _config__WEBPACK_IMPORTED_MODULE_2__.Z9)({
+                cwd: options.root,
+                path: options.config,
+                configLoader: options.configLoader
+            });
+            const keys = [
+                'root',
+                'globals',
+                'isolate',
+                'passWithNoTests',
+                'update',
+                'testNamePattern',
+                'testTimeout',
+                'hookTimeout',
+                'clearMocks',
+                'resetMocks',
+                'restoreMocks',
+                'unstubEnvs',
+                'unstubGlobals',
+                'retry',
+                'slowTestThreshold',
+                'maxConcurrency',
+                'printConsoleTrace',
+                'disableConsoleIntercept',
+                'testEnvironment'
+            ];
+            for (const key of keys)if (void 0 !== options[key]) config[key] = options[key];
+            if (options.reporter) config.reporters = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.bg)(options.reporter);
+            if (options.exclude) config.exclude = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.bg)(options.exclude);
+            if (options.include) config.include = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.bg)(options.include);
+            return {
+                config,
+                configFilePath: configFilePath ?? void 0
+            };
+        }
+        async function resolveProjects({ config, root, options }) {
+            if (!config.projects || !config.projects.length) return [];
+            const getDefaultProjectName = (dir)=>{
+                const pkgJsonPath = (0, pathe__WEBPACK_IMPORTED_MODULE_1__.resolve)(dir, 'package.json');
+                const name = (0, node_fs__WEBPACK_IMPORTED_MODULE_0__.existsSync)(pkgJsonPath) ? JSON.parse((0, node_fs__WEBPACK_IMPORTED_MODULE_0__.readFileSync)(pkgJsonPath, 'utf-8')).name : '';
+                if ('string' != typeof name || !name) return (0, pathe__WEBPACK_IMPORTED_MODULE_1__.basename)(dir);
+                return name;
+            };
+            const globProjects = async (patterns)=>{
+                const globOptions = {
+                    absolute: true,
+                    dot: true,
+                    onlyFiles: false,
+                    cwd: root,
+                    expandDirectories: false,
+                    ignore: [
+                        '**/node_modules/**',
+                        '**/.DS_Store'
+                    ]
+                };
+                return (0, tinyglobby__WEBPACK_IMPORTED_MODULE_4__.glob)(patterns, globOptions);
+            };
+            const { projectPaths, projectPatterns } = (config.projects || []).reduce((total, p)=>{
+                const projectStr = p.replace('<rootDir>', root);
+                if ((0, tinyglobby__WEBPACK_IMPORTED_MODULE_4__.ey)(projectStr)) total.projectPatterns.push(projectStr);
+                else {
+                    const absolutePath = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.FI)(root, projectStr);
+                    if (!(0, node_fs__WEBPACK_IMPORTED_MODULE_0__.existsSync)(absolutePath)) throw `Can't resolve project "${p}", please make sure "${p}" is a existing file or a directory.`;
+                    total.projectPaths.push(absolutePath);
+                }
+                return total;
+            }, {
+                projectPaths: [],
+                projectPatterns: []
+            });
+            projectPaths.push(...await globProjects(projectPatterns));
+            const projects = await Promise.all(projectPaths.map(async (project)=>{
+                const isDirectory = (0, node_fs__WEBPACK_IMPORTED_MODULE_0__.statSync)(project).isDirectory();
+                const { config, configFilePath } = await resolveConfig({
+                    ...options,
+                    config: isDirectory ? void 0 : project,
+                    root: isDirectory ? project : (0, pathe__WEBPACK_IMPORTED_MODULE_1__.dirname)(project)
+                });
+                config.name ??= getDefaultProjectName(project);
+                if (config.projects?.length && config.root !== root) _utils__WEBPACK_IMPORTED_MODULE_3__.vF.warn(`Projects cannot have nested projects, the "projects" field in project "${config.name}" will be ignored.`);
+                return {
+                    config,
+                    configFilePath
+                };
+            }));
+            const names = new Set();
+            projects.forEach((project)=>{
+                if (names.has(project.config.name)) {
+                    const conflictProjects = projects.filter((p)=>p.config.name === project.config.name);
+                    throw `Project name "${project.config.name}" is already used. Please ensure all projects have unique names.
+Conflicting projects:
+${conflictProjects.map((p)=>`- ${p.configFilePath || p.config.root}`).join('\n')}
+        `;
+                }
+                names.add(project.config.name);
+            });
+            return projects;
+        }
+        async function initCli(options) {
+            const cwd = process.cwd();
+            const root = options.root ? (0, _utils__WEBPACK_IMPORTED_MODULE_3__.FI)(cwd, options.root) : cwd;
+            const { config, configFilePath } = await resolveConfig({
+                ...options,
+                root
+            });
+            const projects = await resolveProjects({
+                config,
+                root,
+                options
+            });
+            return {
+                config,
+                configFilePath,
+                projects
+            };
+        }
+    }
+};