@rstest/core 0.6.0 → 0.6.2

package/dist/0~836.js

@@ -1,26 +1,18 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
-export const __webpack_id__ = "836";
-export const __webpack_ids__ = [
-    "836"
-];
-export const __webpack_modules__ = {
-    "./src/coverage/plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            pluginCoverageCore: ()=>pluginCoverageCore
-        });
-        var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("node:fs");
-        const pluginCoverageCore = (coverageOptions)=>({
-                name: 'rstest:coverage-core',
-                setup: (api)=>{
-                    api.onBeforeDevCompile(({ isFirstCompile })=>{
-                        if (isFirstCompile && coverageOptions.clean) {
-                            if (node_fs__WEBPACK_IMPORTED_MODULE_0__["default"].existsSync(coverageOptions.reportsDirectory)) node_fs__WEBPACK_IMPORTED_MODULE_0__["default"].rmSync(coverageOptions.reportsDirectory, {
-                                recursive: true
-                            });
-                        }
+import { __webpack_require__ } from "./runtime.js";
+import "./857.js";
+const external_node_fs_ = __webpack_require__("node:fs");
+const pluginCoverageCore = (coverageOptions)=>({
+        name: 'rstest:coverage-core',
+        setup: (api)=>{
+            api.onBeforeDevCompile(({ isFirstCompile })=>{
+                if (isFirstCompile && coverageOptions.clean) {
+                    if (external_node_fs_["default"].existsSync(coverageOptions.reportsDirectory)) external_node_fs_["default"].rmSync(coverageOptions.reportsDirectory, {
+                        recursive: true
                     });
                 }
             });
-    }
-};
+        }
+    });
+export { pluginCoverageCore };

package/dist/0~971.js

@@ -1,144 +1,138 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
-export const __webpack_id__ = "971";
-export const __webpack_ids__ = [
-    "971"
-];
-export const __webpack_modules__ = {
-    "./src/core/listTests.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            listTests: ()=>listTests
+import { __webpack_require__ } from "./runtime.js";
+import { getTestEntries, getSetupFiles, getTaskNameWithPrefix, prettyTestPath, src_logger } from "./857.js";
+import { prepareRsbuild, createPool, createRsbuildServer } from "./0~814.js";
+const external_node_fs_ = __webpack_require__("node:fs");
+const external_node_path_ = __webpack_require__("node:path");
+const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+async function listTests(context, { filesOnly, json }) {
+    const { rootPath } = context;
+    const testEntries = {};
+    const globTestSourceEntries = async (name)=>{
+        if (testEntries[name]) return testEntries[name];
+        const { include, exclude, includeSource, root } = context.projects.find((p)=>p.environmentName === name).normalizedConfig;
+        const entries = await getTestEntries({
+            include,
+            exclude: exclude.patterns,
+            rootPath,
+            projectRoot: root,
+            fileFilters: context.fileFilters || [],
+            includeSource
         });
-        var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("node:fs");
-        var node_path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("node:path");
-        var _pool__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./src/pool/index.ts");
-        var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./src/utils/index.ts");
-        var _rsbuild__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("./src/core/rsbuild.ts");
-        async function listTests(context, { filesOnly, json }) {
-            const { rootPath } = context;
-            const testEntries = {};
-            const globTestSourceEntries = async (name)=>{
-                if (testEntries[name]) return testEntries[name];
-                const { include, exclude, includeSource, root } = context.projects.find((p)=>p.environmentName === name).normalizedConfig;
-                const entries = await (0, _utils__WEBPACK_IMPORTED_MODULE_3__.tG)({
-                    include,
-                    exclude: exclude.patterns,
-                    rootPath,
-                    projectRoot: root,
-                    fileFilters: context.fileFilters || [],
-                    includeSource
-                });
-                testEntries[name] = entries;
-                return entries;
-            };
-            const setupFiles = Object.fromEntries(context.projects.map((project)=>{
-                const { environmentName, rootPath, normalizedConfig: { setupFiles } } = project;
-                return [
-                    environmentName,
-                    (0, _utils__WEBPACK_IMPORTED_MODULE_3__.pr)(setupFiles, rootPath)
-                ];
+        testEntries[name] = entries;
+        return entries;
+    };
+    const setupFiles = Object.fromEntries(context.projects.map((project)=>{
+        const { environmentName, rootPath, normalizedConfig: { setupFiles } } = project;
+        return [
+            environmentName,
+            getSetupFiles(setupFiles, rootPath)
+        ];
+    }));
+    const rsbuildInstance = await prepareRsbuild(context, globTestSourceEntries, setupFiles);
+    const { getRsbuildStats, closeServer } = await createRsbuildServer({
+        globTestSourceEntries,
+        inspectedConfig: {
+            ...context.normalizedConfig,
+            projects: context.projects.map((p)=>p.normalizedConfig)
+        },
+        setupFiles,
+        rsbuildInstance,
+        rootPath
+    });
+    const pool = await createPool({
+        context
+    });
+    const updateSnapshot = context.snapshotManager.options.updateSnapshot;
+    const returns = await Promise.all(context.projects.map(async (project)=>{
+        const { entries, setupEntries, getSourceMaps, getAssetFiles, assetNames } = await getRsbuildStats({
+            environmentName: project.environmentName
+        });
+        const list = await pool.collectTests({
+            entries,
+            setupEntries,
+            getAssetFiles,
+            getSourceMaps,
+            project,
+            updateSnapshot
+        });
+        return {
+            list,
+            getSourceMaps,
+            assetNames
+        };
+    }));
+    const list = returns.flatMap((r)=>r.list);
+    const tests = [];
+    const traverseTests = (test)=>{
+        if ([
+            'skip',
+            'todo'
+        ].includes(test.runMode)) return;
+        if ('case' === test.type) if (showProject) tests.push({
+            file: test.testPath,
+            name: getTaskNameWithPrefix(test),
+            project: test.project
+        });
+        else tests.push({
+            file: test.testPath,
+            name: getTaskNameWithPrefix(test)
+        });
+        else for (const child of test.tests)traverseTests(child);
+    };
+    const hasError = list.some((file)=>file.errors?.length);
+    const showProject = context.projects.length > 1;
+    if (hasError) {
+        const { printError } = await import("./index.js").then((mod)=>({
+                printError: mod.error_printError
             }));
-            const rsbuildInstance = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_4__.zh)(context, globTestSourceEntries, setupFiles);
-            const { getRsbuildStats, closeServer } = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_4__.XD)({
-                globTestSourceEntries,
-                inspectedConfig: {
-                    ...context.normalizedConfig,
-                    projects: context.projects.map((p)=>p.normalizedConfig)
-                },
-                setupFiles,
-                rsbuildInstance,
-                rootPath
+        process.exitCode = 1;
+        for (const file of list){
+            const relativePath = (0, external_node_path_.relative)(rootPath, file.testPath);
+            if (file.errors?.length) {
+                src_logger.log(`${picocolors_default().bgRed(' FAIL ')} ${relativePath}`);
+                for (const error of file.errors)await printError(error, async (name)=>{
+                    const resource = returns.find((r)=>r.assetNames.includes(name));
+                    const sourceMap = (await resource?.getSourceMaps([
+                        name
+                    ]))?.[name];
+                    return sourceMap ? JSON.parse(sourceMap) : null;
+                }, rootPath);
+            }
+        }
+        await closeServer();
+        await pool.close();
+        return;
+    }
+    for (const file of list){
+        if (filesOnly) {
+            if (showProject) tests.push({
+                file: file.testPath,
+                project: file.project
             });
-            const pool = await (0, _pool__WEBPACK_IMPORTED_MODULE_2__.b)({
-                context
+            else tests.push({
+                file: file.testPath
             });
-            const updateSnapshot = context.snapshotManager.options.updateSnapshot;
-            const returns = await Promise.all(context.projects.map(async (project)=>{
-                const { entries, setupEntries, getSourceMaps, getAssetFiles, assetNames } = await getRsbuildStats({
-                    environmentName: project.environmentName
-                });
-                const list = await pool.collectTests({
-                    entries,
-                    setupEntries,
-                    getAssetFiles,
-                    getSourceMaps,
-                    project,
-                    updateSnapshot
-                });
-                return {
-                    list,
-                    getSourceMaps,
-                    assetNames
-                };
-            }));
-            const list = returns.flatMap((r)=>r.list);
-            const tests = [];
-            const traverseTests = (test)=>{
-                if ([
-                    'skip',
-                    'todo'
-                ].includes(test.runMode)) return;
-                if ('case' === test.type) if (showProject) tests.push({
-                    file: test.testPath,
-                    name: (0, _utils__WEBPACK_IMPORTED_MODULE_3__.fN)(test),
-                    project: test.project
-                });
-                else tests.push({
-                    file: test.testPath,
-                    name: (0, _utils__WEBPACK_IMPORTED_MODULE_3__.fN)(test)
-                });
-                else for (const child of test.tests)traverseTests(child);
-            };
-            const hasError = list.some((file)=>file.errors?.length);
-            const showProject = context.projects.length > 1;
-            if (hasError) {
-                const { printError } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "./src/utils/error.ts"));
-                process.exitCode = 1;
-                for (const file of list){
-                    const relativePath = (0, node_path__WEBPACK_IMPORTED_MODULE_1__.relative)(rootPath, file.testPath);
-                    if (file.errors?.length) {
-                        _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log(`${_utils__WEBPACK_IMPORTED_MODULE_3__.yW.bgRed(' FAIL ')} ${relativePath}`);
-                        for (const error of file.errors)await printError(error, async (name)=>{
-                            const resource = returns.find((r)=>r.assetNames.includes(name));
-                            const sourceMap = (await resource?.getSourceMaps([
-                                name
-                            ]))?.[name];
-                            return sourceMap ? JSON.parse(sourceMap) : null;
-                        }, rootPath);
-                    }
-                }
-                await closeServer();
-                await pool.close();
-                return;
-            }
-            for (const file of list){
-                if (filesOnly) {
-                    if (showProject) tests.push({
-                        file: file.testPath,
-                        project: file.project
-                    });
-                    else tests.push({
-                        file: file.testPath
-                    });
-                    continue;
-                }
-                for (const test of file.tests)traverseTests(test);
-            }
-            if (json && 'false' !== json) {
-                const content = JSON.stringify(tests, null, 2);
-                if (true !== json && 'true' !== json) {
-                    const jsonPath = (0, node_path__WEBPACK_IMPORTED_MODULE_1__.isAbsolute)(json) ? json : (0, node_path__WEBPACK_IMPORTED_MODULE_1__.join)(rootPath, json);
-                    (0, node_fs__WEBPACK_IMPORTED_MODULE_0__.mkdirSync)((0, node_path__WEBPACK_IMPORTED_MODULE_1__.dirname)(jsonPath), {
-                        recursive: true
-                    });
-                    (0, node_fs__WEBPACK_IMPORTED_MODULE_0__.writeFileSync)(jsonPath, content);
-                } else _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log(content);
-            } else for (const test of tests){
-                const shortPath = (0, node_path__WEBPACK_IMPORTED_MODULE_1__.relative)(rootPath, test.file);
-                _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log(test.name ? `${_utils__WEBPACK_IMPORTED_MODULE_3__.yW.dim(`${shortPath} > `)}${test.name}` : (0, _utils__WEBPACK_IMPORTED_MODULE_3__.EQ)(shortPath));
-            }
-            await closeServer();
-            await pool.close();
+            continue;
         }
+        for (const test of file.tests)traverseTests(test);
+    }
+    if (json && 'false' !== json) {
+        const content = JSON.stringify(tests, null, 2);
+        if (true !== json && 'true' !== json) {
+            const jsonPath = (0, external_node_path_.isAbsolute)(json) ? json : (0, external_node_path_.join)(rootPath, json);
+            (0, external_node_fs_.mkdirSync)((0, external_node_path_.dirname)(jsonPath), {
+                recursive: true
+            });
+            (0, external_node_fs_.writeFileSync)(jsonPath, content);
+        } else src_logger.log(content);
+    } else for (const test of tests){
+        const shortPath = (0, external_node_path_.relative)(rootPath, test.file);
+        src_logger.log(test.name ? `${picocolors_default().dim(`${shortPath} > `)}${test.name}` : prettyTestPath(shortPath));
     }
-};
+    await closeServer();
+    await pool.close();
+}
+export { listTests };

package/dist/597.js

@@ -0,0 +1,174 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for(let i = 0; i < chars.length; i++){
+    const c = chars.charCodeAt(i);
+    intToChar[i] = c;
+    charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+    let value = 0;
+    let shift = 0;
+    let integer = 0;
+    do {
+        const c = reader.next();
+        integer = charToInt[c];
+        value |= (31 & integer) << shift;
+        shift += 5;
+    }while (32 & integer);
+    const shouldNegate = 1 & value;
+    value >>>= 1;
+    if (shouldNegate) value = -2147483648 | -value;
+    return relative + value;
+}
+function encodeInteger(builder, num, relative) {
+    let delta = num - relative;
+    delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+    do {
+        let clamped = 31 & delta;
+        delta >>>= 5;
+        if (delta > 0) clamped |= 32;
+        builder.write(intToChar[clamped]);
+    }while (delta > 0);
+    return num;
+}
+function hasMoreVlq(reader, max) {
+    if (reader.pos >= max) return false;
+    return reader.peek() !== comma;
+}
+var bufLength = 16384;
+var td = "undefined" != typeof TextDecoder ? /* @__PURE__ */ new TextDecoder() : "undefined" != typeof Buffer ? {
+    decode (buf) {
+        const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+        return out.toString();
+    }
+} : {
+    decode (buf) {
+        let out = "";
+        for(let i = 0; i < buf.length; i++)out += String.fromCharCode(buf[i]);
+        return out;
+    }
+};
+var StringWriter = class {
+    constructor(){
+        this.pos = 0;
+        this.out = "";
+        this.buffer = new Uint8Array(bufLength);
+    }
+    write(v) {
+        const { buffer } = this;
+        buffer[this.pos++] = v;
+        if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+        }
+    }
+    flush() {
+        const { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    }
+};
+var StringReader = class {
+    constructor(buffer){
+        this.pos = 0;
+        this.buffer = buffer;
+    }
+    next() {
+        return this.buffer.charCodeAt(this.pos++);
+    }
+    peek() {
+        return this.buffer.charCodeAt(this.pos);
+    }
+    indexOf(char) {
+        const { buffer, pos } = this;
+        const idx = buffer.indexOf(char, pos);
+        return -1 === idx ? buffer.length : idx;
+    }
+};
+function decode(mappings) {
+    const { length } = mappings;
+    const reader = new StringReader(mappings);
+    const decoded = [];
+    let genColumn = 0;
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
+    do {
+        const semi = reader.indexOf(";");
+        const line = [];
+        let sorted = true;
+        let lastCol = 0;
+        genColumn = 0;
+        while(reader.pos < semi){
+            let seg;
+            genColumn = decodeInteger(reader, genColumn);
+            if (genColumn < lastCol) sorted = false;
+            lastCol = genColumn;
+            if (hasMoreVlq(reader, semi)) {
+                sourcesIndex = decodeInteger(reader, sourcesIndex);
+                sourceLine = decodeInteger(reader, sourceLine);
+                sourceColumn = decodeInteger(reader, sourceColumn);
+                if (hasMoreVlq(reader, semi)) {
+                    namesIndex = decodeInteger(reader, namesIndex);
+                    seg = [
+                        genColumn,
+                        sourcesIndex,
+                        sourceLine,
+                        sourceColumn,
+                        namesIndex
+                    ];
+                } else seg = [
+                    genColumn,
+                    sourcesIndex,
+                    sourceLine,
+                    sourceColumn
+                ];
+            } else seg = [
+                genColumn
+            ];
+            line.push(seg);
+            reader.pos++;
+        }
+        if (!sorted) sort(line);
+        decoded.push(line);
+        reader.pos = semi + 1;
+    }while (reader.pos <= length);
+    return decoded;
+}
+function sort(line) {
+    line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+    return a[0] - b[0];
+}
+function encode(decoded) {
+    const writer = new StringWriter();
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
+    for(let i = 0; i < decoded.length; i++){
+        const line = decoded[i];
+        if (i > 0) writer.write(semicolon);
+        if (0 === line.length) continue;
+        let genColumn = 0;
+        for(let j = 0; j < line.length; j++){
+            const segment = line[j];
+            if (j > 0) writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
+            if (1 !== segment.length) {
+                sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+                sourceLine = encodeInteger(writer, segment[2], sourceLine);
+                sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+                if (4 !== segment.length) namesIndex = encodeInteger(writer, segment[4], namesIndex);
+            }
+        }
+    }
+    return writer.flush();
+}
+export { decode, encode };

package/dist/603.js

@@ -0,0 +1,41 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./runtime.js";
+import { external_node_module_createRequire } from "./857.js";
+import { pathToFileURL } from "./808.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);
+const CoverageProviderMap = {
+    istanbul: '@rstest/coverage-istanbul'
+};
+const loadCoverageProvider = async (options, root)=>{
+    const rootPath = pathToFileURL(root).toString();
+    const moduleName = CoverageProviderMap[options.provider || 'istanbul'];
+    if (!moduleName) throw new Error(`Unknown coverage provider: ${options.provider}`);
+    try {
+        const require = external_node_module_createRequire(rootPath);
+        const modulePath = require.resolve(moduleName, {
+            paths: [
+                rootPath
+            ]
+        });
+        const { pluginCoverage, CoverageProvider } = await import(pathToFileURL(modulePath).toString());
+        return {
+            pluginCoverage,
+            CoverageProvider
+        };
+    } catch  {
+        const error = new Error(`Failed to load coverage provider module: ${picocolors_default().cyan(moduleName)} in ${picocolors_default().underline(root)}, please make sure it is installed.\n`);
+        error.stack = '';
+        throw error;
+    }
+};
+async function createCoverageProvider(options, root) {
+    if (!options.enabled) return null;
+    if (!options.provider || CoverageProviderMap[options.provider]) {
+        const { CoverageProvider } = await loadCoverageProvider(options, root);
+        return new CoverageProvider(options);
+    }
+    throw new Error(`Unknown coverage provider: ${options.provider}`);
+}
+export { createCoverageProvider, loadCoverageProvider };