@rstest/core 0.9.1 → 0.9.3

package/dist/{1157.js → 4411.js}

@@ -1,10 +1,12 @@
 import "node:module";
 import { __webpack_require__ } from "./rslib-runtime.js";
-import promises, { lstat, readdir, realpath, stat as promises_stat } from "node:fs/promises";
+import promises from "node:fs/promises";
+import node_fs, * as __rspack_external_node_fs_5ea92f0c from "node:fs";
+import node_path, { basename, dirname, normalize, posix, relative as external_node_path_relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
-import { logger as logger_logger, parsePosix, color, castArray } from "./3160.js";
-import { posix } from "./7011.js";
+import { logger as logger_logger, parsePosix, color as logger_color, castArray } from "./6830.js";
+import { posix as dist_posix } from "./7011.js";
 __webpack_require__.add({
     "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js" (module, __unused_rspack_exports, __webpack_require__) {
         const pico = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js");
@@ -1441,12 +1443,10 @@ const globalApis = [
     'onTestFailed'
 ];
 const TS_CONFIG_FILE = 'tsconfig.json';
-const external_node_path_ = __webpack_require__("path");
-const external_node_fs_ = __webpack_require__("node:fs");
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 function cleanPath(path) {
-    let normalized = (0, external_node_path_.normalize)(path);
-    if (normalized.length > 1 && normalized[normalized.length - 1] === external_node_path_.sep) normalized = normalized.substring(0, normalized.length - 1);
+    let normalized = normalize(path);
+    if (normalized.length > 1 && normalized[normalized.length - 1] === sep) normalized = normalized.substring(0, normalized.length - 1);
     return normalized;
 }
 const SLASHES_REGEX = /[\\/]/g;
@@ -1460,7 +1460,7 @@ function isRootDirectory(path) {
 function normalizePath(path, options) {
     const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
     const pathNeedsCleaning = "win32" === process.platform && path.includes("/") || path.startsWith(".");
-    if (resolvePaths) path = (0, external_node_path_.resolve)(path);
+    if (resolvePaths) path = resolve(path);
     if (normalizePath$1 || pathNeedsCleaning) path = cleanPath(path);
     if ("." === path) return "";
     const needsSeperator = path[path.length - 1] !== pathSeparator;
@@ -1473,7 +1473,7 @@ function joinPathWithRelativePath(root, options) {
     return function(filename, directoryPath) {
         const sameRoot = directoryPath.startsWith(root);
         if (sameRoot) return directoryPath.slice(root.length) + filename;
-        return convertSlashes((0, external_node_path_.relative)(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+        return convertSlashes(external_node_path_relative(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
     };
 }
 function joinPath(filename) {
@@ -1580,13 +1580,13 @@ function build$2(options, isSynchronous) {
 }
 function isRecursive(path, resolved, state) {
     if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
-    let parent = (0, external_node_path_.dirname)(path);
+    let parent = dirname(path);
     let depth = 1;
     while(parent !== state.root && depth < 2){
         const resolvedPath = state.symlinks.get(parent);
         const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
         if (isSameRoot) depth++;
-        else parent = (0, external_node_path_.dirname)(parent);
+        else parent = dirname(parent);
     }
     state.symlinks.set(path, resolved);
     return depth > 1;
@@ -1728,7 +1728,7 @@ var Walker = class {
                 ""
             ].slice(0, 0),
             controller: new Aborter(),
-            fs: options.fs || external_node_fs_
+            fs: options.fs || __rspack_external_node_fs_5ea92f0c
         };
         this.joinPath = build$7(this.root, options);
         this.pushDirectory = build$6(this.root, options);
@@ -1766,8 +1766,8 @@ var Walker = class {
                         this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
                     } else {
                         resolvedPath = useRealPaths ? resolvedPath : path;
-                        const filename = (0, external_node_path_.basename)(resolvedPath);
-                        const directoryPath$1 = normalizePath((0, external_node_path_.dirname)(resolvedPath), this.state.options);
+                        const filename = basename(resolvedPath);
+                        const directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options);
                         resolvedPath = this.joinPath(filename, directoryPath$1);
                         this.pushFile(resolvedPath, files, this.state.counts, filters);
                     }
@@ -1818,7 +1818,7 @@ var Builder = class {
     options = {
         maxDepth: 1 / 0,
         suppressErrors: true,
-        pathSeparator: external_node_path_.sep,
+        pathSeparator: sep,
         filters: []
     };
     globFunction;
@@ -1983,8 +1983,8 @@ function buildFormat(cwd, root, absolute) {
         };
         return (p, isDir)=>isDir && "." !== p ? p.slice(0, -1) : p;
     }
-    if (absolute) return (p)=>external_node_path_.posix.relative(cwd, p) || ".";
-    return (p)=>external_node_path_.posix.relative(cwd, `${root}/${p}`) || ".";
+    if (absolute) return (p)=>posix.relative(cwd, p) || ".";
+    return (p)=>posix.relative(cwd, `${root}/${p}`) || ".";
 }
 function buildRelative(cwd, root) {
     if (root.startsWith(`${cwd}/`)) {
@@ -1992,7 +1992,7 @@ function buildRelative(cwd, root) {
         return (p)=>`${prefix}/${p}`;
     }
     return (p)=>{
-        const result = external_node_path_.posix.relative(cwd, `${root}/${p}`);
+        const result = posix.relative(cwd, `${root}/${p}`);
         if (p.endsWith("/") && "" !== result) return `${result}/`;
         return result || ".";
     };
@@ -2028,7 +2028,7 @@ function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
     if (pattern.endsWith("/")) result = pattern.slice(0, -1);
     if (!result.endsWith("*") && expandDirectories) result += "/**";
     const escapedCwd = escapePath(cwd);
-    result = external_node_path_["default"].isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? external_node_path_.posix.relative(escapedCwd, result) : external_node_path_.posix.normalize(result);
+    result = node_path.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? posix.relative(escapedCwd, result) : posix.normalize(result);
     const parentDirectoryMatch = PARENT_DIRECTORY.exec(result);
     const parts = splitPattern(result);
     if (null == parentDirectoryMatch ? void 0 : parentDirectoryMatch[0]) {
@@ -2039,7 +2039,7 @@ function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
             result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".";
             i++;
         }
-        const potentialRoot = external_node_path_.posix.join(cwd, parentDirectoryMatch[0].slice(3 * i));
+        const potentialRoot = posix.join(cwd, parentDirectoryMatch[0].slice(3 * i));
         if (!potentialRoot.startsWith(".") && props.root.length > potentialRoot.length) {
             props.root = potentialRoot;
             props.depthOffset = -n + i;
@@ -2060,7 +2060,7 @@ function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
         }
         props.depthOffset = newCommonPath.length;
         props.commonPath = newCommonPath;
-        props.root = newCommonPath.length > 0 ? external_node_path_.posix.join(cwd, ...newCommonPath) : cwd;
+        props.root = newCommonPath.length > 0 ? posix.join(cwd, ...newCommonPath) : cwd;
     }
     return result;
 }
@@ -2097,7 +2097,7 @@ function formatPaths(paths, relative) {
 function normalizeCwd(cwd) {
     if (!cwd) return process.cwd().replace(BACKSLASHES, "/");
     if (cwd instanceof URL) return fileURLToPath(cwd).replace(BACKSLASHES, "/");
-    return external_node_path_["default"].resolve(cwd).replace(BACKSLASHES, "/");
+    return node_path.resolve(cwd).replace(BACKSLASHES, "/");
 }
 function getCrawler(patterns, inputOptions = {}) {
     const options = process.env.TINYGLOBBY_DEBUG ? {
@@ -2162,12 +2162,12 @@ function getCrawler(patterns, inputOptions = {}) {
             return "." !== relativePath && !partialMatcher(relativePath) || ignore(relativePath);
         },
         fs: options.fs ? {
-            readdir: options.fs.readdir || external_node_fs_["default"].readdir,
-            readdirSync: options.fs.readdirSync || external_node_fs_["default"].readdirSync,
-            realpath: options.fs.realpath || external_node_fs_["default"].realpath,
-            realpathSync: options.fs.realpathSync || external_node_fs_["default"].realpathSync,
-            stat: options.fs.stat || external_node_fs_["default"].stat,
-            statSync: options.fs.statSync || external_node_fs_["default"].statSync
+            readdir: options.fs.readdir || node_fs.readdir,
+            readdirSync: options.fs.readdirSync || node_fs.readdirSync,
+            realpath: options.fs.realpath || node_fs.realpath,
+            realpathSync: options.fs.realpathSync || node_fs.realpathSync,
+            stat: options.fs.stat || node_fs.stat,
+            statSync: options.fs.statSync || node_fs.statSync
         } : void 0,
         pathSeparator: "/",
         relativePaths: true,
@@ -2208,12 +2208,12 @@ async function glob(patternsOrOptions, options) {
 }
 const filterFiles = (testFiles, filters, dir)=>{
     if (!filters.length) return testFiles;
-    const fileFilters = 'win32' === process.platform ? filters.map((f)=>f.split(posix.sep).join('/')) : filters;
+    const fileFilters = 'win32' === process.platform ? filters.map((f)=>f.split(dist_posix.sep).join('/')) : filters;
     return testFiles.filter((t)=>{
-        const testFile = posix.relative(dir, t).toLocaleLowerCase();
+        const testFile = dist_posix.relative(dir, t).toLocaleLowerCase();
         return fileFilters.some((f)=>{
-            if (posix.isAbsolute(f) && t.startsWith(f)) return true;
-            const relativePath = f.endsWith('/') ? posix.join(posix.relative(dir, f), '/') : posix.relative(dir, f);
+            if (dist_posix.isAbsolute(f) && t.startsWith(f)) return true;
+            const relativePath = f.endsWith('/') ? dist_posix.join(dist_posix.relative(dir, f), '/') : dist_posix.relative(dir, f);
             return testFile.includes(f.toLocaleLowerCase()) || testFile.includes(relativePath.toLocaleLowerCase());
         });
     });
@@ -2257,7 +2257,7 @@ const getTestEntries = async ({ include, exclude, rootPath, projectRoot, fileFil
         }));
     }
     return Object.fromEntries(filterFiles(testFiles, fileFilters, rootPath).map((entry)=>{
-        const relativePath = posix.relative(rootPath, entry);
+        const relativePath = dist_posix.relative(rootPath, entry);
         return [
             formatTestEntryName(relativePath),
             entry
@@ -2266,11 +2266,11 @@ const getTestEntries = async ({ include, exclude, rootPath, projectRoot, fileFil
 };
 const prettyTestPath = (testPath)=>{
     const { dir, base } = parsePosix(testPath);
-    return `${'.' !== dir ? color.gray(`${dir}/`) : ''}${color.cyan(base)}`;
+    return `${'.' !== dir ? logger_color.gray(`${dir}/`) : ''}${logger_color.cyan(base)}`;
 };
 const formatTestPath = (root, testFilePath)=>{
     let testPath = testFilePath;
-    if (posix.isAbsolute(testPath) && testPath.includes(root)) testPath = posix.relative(root, testPath);
+    if (dist_posix.isAbsolute(testPath) && testPath.includes(root)) testPath = dist_posix.relative(root, testPath);
     return prettyTestPath(testPath);
 };
 function getShardedFiles(files, shard) {
@@ -2304,7 +2304,7 @@ async function resolveShardedEntries(context) {
     const shardedEntries = getShardedFiles(allTestEntriesBeforeSharding, shard);
     const totalTestFileCount = allTestEntriesBeforeSharding.length;
     const testFilesInShardCount = shardedEntries.length;
-    logger_logger.log(color.green(`Running shard ${shard.index} of ${shard.count} (${testFilesInShardCount} of ${totalTestFileCount} test files)\n`));
+    logger_logger.log(logger_color.green(`Running shard ${shard.index} of ${shard.count} (${testFilesInShardCount} of ${totalTestFileCount} test files)\n`));
     const shardedEntriesByProject = new Map();
     for (const { project, alias, testPath } of shardedEntries){
         if (!shardedEntriesByProject.has(project)) shardedEntriesByProject.set(project, {});
@@ -2317,4 +2317,4 @@ async function resolveShardedEntries(context) {
     });
     return entriesCache;
 }
-export { DEFAULT_CONFIG_EXTENSIONS, DEFAULT_CONFIG_NAME, ROOT_SUITE_NAME, TEMP_RSTEST_OUTPUT_DIR, TEMP_RSTEST_OUTPUT_DIR_GLOB, TS_CONFIG_FILE, filterProjects, formatTestEntryName, formatTestPath, getTestEntries, glob, globalApis, isDynamicPattern, lstat, prettyTestPath, promises, promises_stat, readdir, realpath, resolveShardedEntries };
+export { DEFAULT_CONFIG_EXTENSIONS, DEFAULT_CONFIG_NAME, ROOT_SUITE_NAME, TEMP_RSTEST_OUTPUT_DIR, TEMP_RSTEST_OUTPUT_DIR_GLOB, TS_CONFIG_FILE, filterProjects, formatTestEntryName, formatTestPath, getTestEntries, glob, globalApis, isDynamicPattern, prettyTestPath, resolveShardedEntries };

package/dist/{4484.js → 5040.js}

@@ -1,5 +1,4 @@
 import "node:module";
-import * as __rspack_external__rsbuild_core_1b356efc from "@rsbuild/core";
 const check = (name)=>{
     if (!globalThis.RSTEST_API?.[name]) throw new Error(`Rstest API '${name}' is not registered yet, please make sure you are running in a rstest environment.`);
 };
@@ -34,4 +33,4 @@ const rstest = wrapRstestUtilitiesAPI('rstest');
 const rs = wrapRstestUtilitiesAPI('rs');
 const onTestFinished = wrapRstestAPI('onTestFinished');
 const onTestFailed = wrapRstestAPI('onTestFailed');
-export { __rspack_external__rsbuild_core_1b356efc as rsbuild, afterAll, afterEach, assert, beforeAll, beforeEach, describe, expect, it, onTestFailed, onTestFinished, rs, rstest, test };
+export { afterAll, afterEach, assert, beforeAll, beforeEach, describe, expect, it, onTestFailed, onTestFinished, rs, rstest, test };