@rstest/core 0.9.5 → 0.9.7

package/dist/4411.js

@@ -1,10 +1,11 @@
 import "node:module";
-import { __webpack_require__ } from "./rslib-runtime.js";
 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 * as __rspack_external_node_fs_5ea92f0c from "node:fs";
+import { readdir, readdirSync, realpath, realpathSync, stat as external_node_fs_stat, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, normalize, posix, relative as external_node_path_relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
+import { __webpack_require__ } from "./0~rslib-runtime.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({
@@ -2115,36 +2116,36 @@ var Builder = class {
 };
 const picomatch = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/index.js");
 const isReadonlyArray = Array.isArray;
+const BACKSLASHES = /\\/g;
 const isWin = "win32" === process.platform;
 const ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
 function getPartialMatcher(patterns, options = {}) {
     const patternsCount = patterns.length;
     const patternsParts = Array(patternsCount);
     const matchers = Array(patternsCount);
-    const globstarEnabled = !options.noglobstar;
-    for(let i = 0; i < patternsCount; i++){
+    let i, j;
+    for(i = 0; i < patternsCount; i++){
         const parts = splitPattern(patterns[i]);
         patternsParts[i] = parts;
         const partsCount = parts.length;
         const partMatchers = Array(partsCount);
-        for(let j = 0; j < partsCount; j++)partMatchers[j] = picomatch(parts[j], options);
+        for(j = 0; j < partsCount; j++)partMatchers[j] = picomatch(parts[j], options);
         matchers[i] = partMatchers;
     }
     return (input)=>{
         const inputParts = input.split("/");
         if (".." === inputParts[0] && ONLY_PARENT_DIRECTORIES.test(input)) return true;
-        for(let i = 0; i < patterns.length; i++){
+        for(i = 0; i < patternsCount; i++){
             const patternParts = patternsParts[i];
             const matcher = matchers[i];
             const inputPatternCount = inputParts.length;
             const minParts = Math.min(inputPatternCount, patternParts.length);
-            let j = 0;
+            j = 0;
             while(j < minParts){
                 const part = patternParts[j];
                 if (part.includes("/")) return true;
-                const match = matcher[j](inputParts[j]);
-                if (!match) break;
-                if (globstarEnabled && "**" === part) return true;
+                if (!matcher[j](inputParts[j])) break;
+                if (!options.noglobstar && "**" === part) return true;
                 j++;
             }
             if (j === inputPatternCount) return true;
@@ -2157,7 +2158,7 @@ const isRoot = isWin ? (p)=>WIN32_ROOT_DIR.test(p) : (p)=>"/" === p;
 function buildFormat(cwd, root, absolute) {
     if (cwd === root || root.startsWith(`${cwd}/`)) {
         if (absolute) {
-            const start = isRoot(cwd) ? cwd.length : cwd.length + 1;
+            const start = cwd.length + +!isRoot(cwd);
             return (p, isDir)=>p.slice(start, isDir ? -1 : void 0) || ".";
         }
         const prefix = root.slice(cwd.length + 1);
@@ -2178,24 +2179,23 @@ function buildRelative(cwd, root) {
     }
     return (p)=>{
         const result = posix.relative(cwd, `${root}/${p}`);
-        if (p.endsWith("/") && "" !== result) return `${result}/`;
-        return result || ".";
+        return "/" === p[p.length - 1] && "" !== result ? `${result}/` : result || ".";
     };
 }
 const splitPatternOptions = {
     parts: true
 };
-function splitPattern(path$1) {
+function splitPattern(path) {
     var _result$parts;
-    const result = picomatch.scan(path$1, splitPatternOptions);
+    const result = picomatch.scan(path, splitPatternOptions);
     return (null == (_result$parts = result.parts) ? void 0 : _result$parts.length) ? result.parts : [
-        path$1
+        path
     ];
 }
 const POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
 const WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
-const escapePosixPath = (path$1)=>path$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
-const escapeWin32Path = (path$1)=>path$1.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapePosixPath = (path)=>path.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapeWin32Path = (path)=>path.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
 const escapePath = isWin ? escapeWin32Path : escapePosixPath;
 function isDynamicPattern(pattern, options) {
     if ((null == options ? void 0 : options.caseSensitiveMatch) === false) return true;
@@ -2205,27 +2205,33 @@ function isDynamicPattern(pattern, options) {
 function log(...tasks) {
     console.log(`[tinyglobby ${/* @__PURE__ */ new Date().toLocaleTimeString("es")}]`, ...tasks);
 }
+function ensureStringArray(value) {
+    return "string" == typeof value ? [
+        value
+    ] : null != value ? value : [];
+}
 const PARENT_DIRECTORY = /^(\/?\.\.)+/;
 const ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
-const BACKSLASHES = /\\/g;
-function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
+function normalizePattern(pattern, opts, props, isIgnore) {
+    var _PARENT_DIRECTORY$exe;
+    const cwd = opts.cwd;
     let result = pattern;
-    if (pattern.endsWith("/")) result = pattern.slice(0, -1);
-    if (!result.endsWith("*") && expandDirectories) result += "/**";
+    if ("/" === pattern[pattern.length - 1]) result = pattern.slice(0, -1);
+    if ("*" !== result[result.length - 1] && opts.expandDirectories) result += "/**";
     const escapedCwd = escapePath(cwd);
-    result = node_path.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? posix.relative(escapedCwd, result) : posix.normalize(result);
-    const parentDirectoryMatch = PARENT_DIRECTORY.exec(result);
+    result = isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? posix.relative(escapedCwd, result) : posix.normalize(result);
+    const parentDir = null == (_PARENT_DIRECTORY$exe = PARENT_DIRECTORY.exec(result)) ? void 0 : _PARENT_DIRECTORY$exe[0];
     const parts = splitPattern(result);
-    if (null == parentDirectoryMatch ? void 0 : parentDirectoryMatch[0]) {
-        const n = (parentDirectoryMatch[0].length + 1) / 3;
+    if (parentDir) {
+        const n = (parentDir.length + 1) / 3;
         let i = 0;
         const cwdParts = escapedCwd.split("/");
         while(i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]){
             result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".";
             i++;
         }
-        const potentialRoot = posix.join(cwd, parentDirectoryMatch[0].slice(3 * i));
-        if (!potentialRoot.startsWith(".") && props.root.length > potentialRoot.length) {
+        const potentialRoot = posix.join(cwd, parentDir.slice(3 * i));
+        if ("." !== potentialRoot[0] && props.root.length > potentialRoot.length) {
             props.root = potentialRoot;
             props.depthOffset = -n + i;
         }
@@ -2240,7 +2246,7 @@ function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
                 newCommonPath.pop();
                 break;
             }
-            if (part !== props.commonPath[i] || isDynamicPattern(part) || i === parts.length - 1) break;
+            if (i === parts.length - 1 || part !== props.commonPath[i] || isDynamicPattern(part)) break;
             newCommonPath.push(part);
         }
         props.depthOffset = newCommonPath.length;
@@ -2249,147 +2255,129 @@ function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
     }
     return result;
 }
-function processPatterns({ patterns = [
-    "**/*"
-], ignore = [], expandDirectories = true }, cwd, props) {
-    if ("string" == typeof patterns) patterns = [
-        patterns
-    ];
-    if ("string" == typeof ignore) ignore = [
-        ignore
-    ];
+function processPatterns(options, patterns, props) {
     const matchPatterns = [];
     const ignorePatterns = [];
-    for (const pattern of ignore)if (pattern) {
-        if ("!" !== pattern[0] || "(" === pattern[1]) ignorePatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, true));
+    for (const pattern of options.ignore)if (pattern) {
+        if ("!" !== pattern[0] || "(" === pattern[1]) ignorePatterns.push(normalizePattern(pattern, options, props, true));
     }
     for (const pattern of patterns)if (pattern) {
-        if ("!" !== pattern[0] || "(" === pattern[1]) matchPatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, false));
-        else if ("!" !== pattern[1] || "(" === pattern[2]) ignorePatterns.push(normalizePattern(pattern.slice(1), expandDirectories, cwd, props, true));
+        if ("!" !== pattern[0] || "(" === pattern[1]) matchPatterns.push(normalizePattern(pattern, options, props, false));
+        else if ("!" !== pattern[1] || "(" === pattern[2]) ignorePatterns.push(normalizePattern(pattern.slice(1), options, props, true));
     }
     return {
         match: matchPatterns,
         ignore: ignorePatterns
     };
 }
-function formatPaths(paths, relative) {
-    for(let i = paths.length - 1; i >= 0; i--){
-        const path$1 = paths[i];
-        paths[i] = relative(path$1);
-    }
-    return paths;
-}
-function normalizeCwd(cwd) {
-    if (!cwd) return process.cwd().replace(BACKSLASHES, "/");
-    if (cwd instanceof URL) return fileURLToPath(cwd).replace(BACKSLASHES, "/");
-    return node_path.resolve(cwd).replace(BACKSLASHES, "/");
-}
-function getCrawler(patterns, inputOptions = {}) {
-    const options = process.env.TINYGLOBBY_DEBUG ? {
-        ...inputOptions,
-        debug: true
-    } : inputOptions;
-    const cwd = normalizeCwd(options.cwd);
-    if (options.debug) log("globbing with:", {
-        patterns,
-        options,
-        cwd
-    });
-    if (Array.isArray(patterns) && 0 === patterns.length) return [
-        {
-            sync: ()=>[],
-            withPromise: async ()=>[]
-        },
-        false
-    ];
+function buildCrawler(options, patterns) {
+    const cwd = options.cwd;
     const props = {
         root: cwd,
-        commonPath: null,
         depthOffset: 0
     };
-    const processed = processPatterns({
-        ...options,
-        patterns
-    }, cwd, props);
+    const processed = processPatterns(options, patterns, props);
     if (options.debug) log("internal processing patterns:", processed);
+    const { absolute, caseSensitiveMatch, debug, dot, followSymbolicLinks, onlyDirectories } = options;
+    const root = props.root.replace(BACKSLASHES, "");
     const matchOptions = {
-        dot: options.dot,
+        dot,
         nobrace: false === options.braceExpansion,
-        nocase: false === options.caseSensitiveMatch,
+        nocase: !caseSensitiveMatch,
         noextglob: false === options.extglob,
         noglobstar: false === options.globstar,
         posix: true
     };
-    const matcher = picomatch(processed.match, {
-        ...matchOptions,
-        ignore: processed.ignore
-    });
+    const matcher = picomatch(processed.match, matchOptions);
     const ignore = picomatch(processed.ignore, matchOptions);
     const partialMatcher = getPartialMatcher(processed.match, matchOptions);
-    const format = buildFormat(cwd, props.root, options.absolute);
-    const formatExclude = options.absolute ? format : buildFormat(cwd, props.root, true);
-    const fdirOptions = {
+    const format = buildFormat(cwd, root, absolute);
+    const excludeFormatter = absolute ? format : buildFormat(cwd, root, true);
+    const excludePredicate = (_, p)=>{
+        const relativePath = excludeFormatter(p, true);
+        return "." !== relativePath && !partialMatcher(relativePath) || ignore(relativePath);
+    };
+    let maxDepth;
+    if (void 0 !== options.deep) maxDepth = Math.round(options.deep - props.depthOffset);
+    const crawler = new Builder({
         filters: [
-            options.debug ? (p, isDirectory)=>{
-                const path$1 = format(p, isDirectory);
-                const matches = matcher(path$1);
-                if (matches) log(`matched ${path$1}`);
+            debug ? (p, isDirectory)=>{
+                const path = format(p, isDirectory);
+                const matches = matcher(path) && !ignore(path);
+                if (matches) log(`matched ${path}`);
                 return matches;
-            } : (p, isDirectory)=>matcher(format(p, isDirectory))
+            } : (p, isDirectory)=>{
+                const path = format(p, isDirectory);
+                return matcher(path) && !ignore(path);
+            }
         ],
-        exclude: options.debug ? (_, p)=>{
-            const relativePath = formatExclude(p, true);
-            const skipped = "." !== relativePath && !partialMatcher(relativePath) || ignore(relativePath);
-            skipped ? log(`skipped ${p}`) : log(`crawling ${p}`);
+        exclude: debug ? (_, p)=>{
+            const skipped = excludePredicate(_, p);
+            log(`${skipped ? "skipped" : "crawling"} ${p}`);
             return skipped;
-        } : (_, p)=>{
-            const relativePath = formatExclude(p, true);
-            return "." !== relativePath && !partialMatcher(relativePath) || ignore(relativePath);
-        },
-        fs: options.fs ? {
-            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,
+        } : excludePredicate,
+        fs: options.fs,
         pathSeparator: "/",
-        relativePaths: true,
-        resolveSymlinks: true,
+        relativePaths: !absolute,
+        resolvePaths: absolute,
+        includeBasePath: absolute,
+        resolveSymlinks: followSymbolicLinks,
+        excludeSymlinks: !followSymbolicLinks,
+        excludeFiles: onlyDirectories,
+        includeDirs: onlyDirectories || !options.onlyFiles,
+        maxDepth,
         signal: options.signal
-    };
-    if (void 0 !== options.deep) fdirOptions.maxDepth = Math.round(options.deep - props.depthOffset);
-    if (options.absolute) {
-        fdirOptions.relativePaths = false;
-        fdirOptions.resolvePaths = true;
-        fdirOptions.includeBasePath = true;
-    }
-    if (false === options.followSymbolicLinks) {
-        fdirOptions.resolveSymlinks = false;
-        fdirOptions.excludeSymlinks = true;
-    }
-    if (options.onlyDirectories) {
-        fdirOptions.excludeFiles = true;
-        fdirOptions.includeDirs = true;
-    } else if (false === options.onlyFiles) fdirOptions.includeDirs = true;
-    props.root = props.root.replace(BACKSLASHES, "");
-    const root = props.root;
-    if (options.debug) log("internal properties:", props);
-    const relative = cwd !== root && !options.absolute && buildRelative(cwd, props.root);
+    }).crawl(root);
+    if (options.debug) log("internal properties:", {
+        ...props,
+        root
+    });
     return [
-        new Builder(fdirOptions).crawl(root),
-        relative
+        crawler,
+        cwd !== root && !absolute && buildRelative(cwd, root)
     ];
 }
-async function glob(patternsOrOptions, options) {
-    if (patternsOrOptions && (null == options ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
-    const isModern = isReadonlyArray(patternsOrOptions) || "string" == typeof patternsOrOptions;
-    const opts = isModern ? options : patternsOrOptions;
-    const patterns = isModern ? patternsOrOptions : patternsOrOptions.patterns;
-    const [crawler, relative] = getCrawler(patterns, opts);
-    if (!relative) return crawler.withPromise();
-    return formatPaths(await crawler.withPromise(), relative);
+function formatPaths(paths, mapper) {
+    if (mapper) for(let i = paths.length - 1; i >= 0; i--)paths[i] = mapper(paths[i]);
+    return paths;
+}
+const defaultOptions = {
+    caseSensitiveMatch: true,
+    cwd: process.cwd(),
+    debug: !!process.env.TINYGLOBBY_DEBUG,
+    expandDirectories: true,
+    followSymbolicLinks: true,
+    onlyFiles: true
+};
+function getOptions(options) {
+    const opts = {
+        ...defaultOptions,
+        ...options
+    };
+    opts.cwd = (opts.cwd instanceof URL ? fileURLToPath(opts.cwd) : resolve(opts.cwd)).replace(BACKSLASHES, "/");
+    opts.ignore = ensureStringArray(opts.ignore);
+    opts.fs && (opts.fs = {
+        readdir: opts.fs.readdir || readdir,
+        readdirSync: opts.fs.readdirSync || readdirSync,
+        realpath: opts.fs.realpath || realpath,
+        realpathSync: opts.fs.realpathSync || realpathSync,
+        stat: opts.fs.stat || external_node_fs_stat,
+        statSync: opts.fs.statSync || statSync
+    });
+    if (opts.debug) log("globbing with options:", opts);
+    return opts;
+}
+function getCrawler(globInput, inputOptions = {}) {
+    var _ref;
+    if (globInput && (null == inputOptions ? void 0 : inputOptions.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+    const isModern = isReadonlyArray(globInput) || "string" == typeof globInput;
+    const patterns = ensureStringArray(null != (_ref = isModern ? globInput : globInput.patterns) ? _ref : "**/*");
+    const options = getOptions(isModern ? inputOptions : globInput);
+    return patterns.length > 0 ? buildCrawler(options, patterns) : [];
+}
+async function glob(globInput, options) {
+    const [crawler, relative] = getCrawler(globInput, options);
+    return crawler ? formatPaths(await crawler.withPromise(), relative) : [];
 }
 const filterFiles = (testFiles, filters, dir)=>{
     if (!filters.length) return testFiles;

package/dist/6830.js

@@ -1,9 +1,9 @@
 import "node:module";
-import { __webpack_require__ } from "./rslib-runtime.js";
 import node_util from "node:util";
 import node_process from "node:process";
 import node_os from "node:os";
 import node_tty from "node:tty";
+import { __webpack_require__ } from "./0~rslib-runtime.js";
 __webpack_require__.add({
     "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js" (module) {
         let p = process || {}, argv = p.argv || [], env = p.env || {};

package/dist/7290.js

@@ -0,0 +1,15 @@
+import "node:module";
+import { __webpack_require__ } from "./0~rslib-runtime.js";
+import { createRequire as __rspack_createRequire } from "node:module";
+const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+__webpack_require__.add({
+    util (module) {
+        module.exports = __rspack_createRequire_require("node:util");
+    },
+    timers (module) {
+        module.exports = __rspack_createRequire_require("timers");
+    },
+    "timers/promises" (module) {
+        module.exports = __rspack_createRequire_require("timers/promises");
+    }
+});

package/dist/9743.js

@@ -1,5 +1,5 @@
 import "node:module";
-import { __webpack_require__ } from "./rslib-runtime.js";
+import { __webpack_require__ } from "./0~rslib-runtime.js";
 import { format as dist_format, dist_plugins, node_u } from "./9784.js";
 var diff_namespaceObject = {};
 __webpack_require__.r(diff_namespaceObject);

package/dist/9784.js

@@ -1,6 +1,6 @@
 /*! LICENSE: 9784.js.LICENSE.txt */
 import "node:module";
-import { __webpack_require__ } from "./rslib-runtime.js";
+import { __webpack_require__ } from "./0~rslib-runtime.js";
 import { isatty } from "node:tty";
 var dist_namespaceObject = {};
 __webpack_require__.r(dist_namespaceObject);