@rstest/browser 0.10.5 → 0.10.6

package/dist/hostController.d.ts

@@ -25,6 +25,7 @@ export declare const createBrowserRsbuildDevConfig: (_isWatchMode: boolean) => {
         logLevel: 'error';
     };
 };
+export declare const createBrowserContextExcludeRegExp: (patterns: string[], projectRoot: string) => RegExp | null;
 // ============================================================================
 // Main Entry Point
 // ============================================================================

package/dist/index.js

@@ -3002,7 +3002,8 @@ const globToRegexp = (glob)=>{
     const regex = picomatch_default().makeRe(glob, {
         fastpaths: false,
         noglobstar: false,
-        bash: false
+        bash: false,
+        dot: true
     });
     if (!regex) throw new Error(`Invalid glob pattern: ${glob}`);
     if (!glob.startsWith('./')) return regex;
@@ -3022,20 +3023,76 @@ const globPatternsToRegExp = (patterns)=>{
     });
     return new RegExp(`(?:${regexParts.join('|')})$`);
 };
-const excludePatternsToRegExp = (patterns)=>{
-    const keywords = [];
-    for (const pattern of patterns){
-        const match = pattern.match(/\*\*\/\.?\{?([^/*{}]+(?:,[^/*{}]+)*)\}?\/?\*?\*?/);
-        if (match) {
-            const parts = match[1].split(',');
-            for (const part of parts){
-                const cleaned = part.replace(/^\./, '');
-                if (cleaned && !keywords.includes(cleaned)) keywords.push(cleaned);
-            }
+const REGEXP_SPECIAL_CHARACTERS = /[|\\{}()[\]^$+*?.]/g;
+const PATH_SEPARATOR_SOURCE = String.raw`[\\/]`;
+const WINDOWS_ABSOLUTE_PATH_SOURCE = String.raw`[A-Za-z]:[\\/]`;
+const escapeRegExp = (value)=>value.replace(REGEXP_SPECIAL_CHARACTERS, '\\$&');
+const normalizePathForRegExp = (value)=>normalize(value).replaceAll('\\', '/');
+const normalizeExcludePatternForRegExp = (value)=>value.startsWith('./') ? `./${normalizePathForRegExp(value.substring(2))}` : normalizePathForRegExp(value);
+const isAbsolutePatternForRegExp = (value)=>value.startsWith('/') || /^[A-Za-z]:\//.test(value);
+const isEscapedRegExpCharacter = (source, index)=>{
+    let backslashCount = 0;
+    for(let current = index - 1; current >= 0 && '\\' === source[current]; current--)backslashCount++;
+    return backslashCount % 2 === 1;
+};
+const replacePathSeparatorsInRegExpSource = (source)=>{
+    let result = '';
+    let inCharacterClass = false;
+    for(let index = 0; index < source.length; index++){
+        const character = source[index];
+        const isEscaped = isEscapedRegExpCharacter(source, index);
+        if ('[' === character && !isEscaped) inCharacterClass = true;
+        if (!inCharacterClass && '\\' === character && '/' === source[index + 1]) {
+            result += PATH_SEPARATOR_SOURCE;
+            index++;
+            continue;
         }
+        result += character;
+        if (']' === character && !isEscaped) inCharacterClass = false;
+    }
+    return result;
+};
+const createRelativeContextExcludeSource = (source, normalizedPattern)=>{
+    if (normalizedPattern.startsWith('./')) return source;
+    return normalizedPattern.startsWith('**/') ? `(?:(?:${source})|\\.(?:${source}))` : `(?:(?:${source})|\\.${PATH_SEPARATOR_SOURCE}(?:${source}))`;
+};
+const createProjectAbsoluteExcludeSource = (source, normalizedPattern)=>normalizedPattern.startsWith('./') || normalizedPattern.startsWith('**/') ? source : `${PATH_SEPARATOR_SOURCE}(?:${source})`;
+const excludePatternsToRegExpSources = (patterns)=>{
+    const sources = patterns.map((pattern)=>{
+        const normalizedPattern = normalizeExcludePatternForRegExp(pattern);
+        const regex = globToRegexp(normalizedPattern);
+        let source = regex.source;
+        if (source.startsWith('^')) source = source.substring(1);
+        if (source.endsWith('$')) source = source.substring(0, source.length - 1);
+        source = replacePathSeparatorsInRegExpSource(source);
+        const isAbsolute = isAbsolutePatternForRegExp(normalizedPattern);
+        const absolute = normalizedPattern.startsWith('./') ? source.substring(2) : source;
+        return {
+            relative: isAbsolute ? source : createRelativeContextExcludeSource(source, normalizedPattern),
+            absolute: isAbsolute ? absolute : createProjectAbsoluteExcludeSource(absolute, normalizedPattern),
+            isAbsolute
+        };
+    });
+    if (0 === sources.length) return null;
+    return sources;
+};
+const createBrowserContextExcludeRegExp = (patterns, projectRoot)=>{
+    const excludeSources = excludePatternsToRegExpSources(patterns);
+    if (!excludeSources) return null;
+    const normalizedProjectRoot = normalizePathForRegExp(projectRoot).replace(/[\\/]$/, '');
+    const projectRootSource = normalizedProjectRoot.split('/').map(escapeRegExp).join(PATH_SEPARATOR_SOURCE);
+    const relativeExcludeSources = excludeSources.filter((source)=>!source.isAbsolute);
+    const absoluteExcludeSources = excludeSources.filter((source)=>source.isAbsolute);
+    const sourceBranches = [];
+    if (relativeExcludeSources.length > 0) {
+        const relativePatternSource = `(?:${relativeExcludeSources.map((source)=>source.relative).join('|')})`;
+        const absolutePatternSource = `(?:${relativeExcludeSources.map((source)=>source.absolute).join('|')})`;
+        const relativeSource = `(?:${relativePatternSource})`;
+        const absoluteSource = normalizedProjectRoot ? `${projectRootSource}(?=${PATH_SEPARATOR_SOURCE})(?:${absolutePatternSource})` : `(?:${absolutePatternSource})`;
+        sourceBranches.push(`(?!${WINDOWS_ABSOLUTE_PATH_SOURCE}|${PATH_SEPARATOR_SOURCE})${relativeSource}`, absoluteSource);
     }
-    if (0 === keywords.length) return null;
-    return new RegExp(`[\\\\/](${keywords.join('|')})[\\\\/]`);
+    if (absoluteExcludeSources.length > 0) sourceBranches.push(`(?:${absoluteExcludeSources.map((source)=>source.relative).join('|')})`);
+    return new RegExp(`^(?:${sourceBranches.join('|')})$`);
 };
 const findTestFileInModules = (modules, entryTestFiles)=>{
     if (!modules) return null;
@@ -3211,7 +3268,7 @@ const generateManifestModule = ({ manifestPath, entries })=>{
         const projectRootPosix = normalize(project.rootPath);
         const includeRegExp = globPatternsToRegExp(project.normalizedConfig.include);
         const excludePatterns = project.normalizedConfig.exclude.patterns;
-        const excludeRegExp = excludePatternsToRegExp(excludePatterns);
+        const excludeRegExp = createBrowserContextExcludeRegExp(excludePatterns, projectRootPosix);
         lines.push(`const ${varName} = import.meta.webpackContext(${JSON.stringify(projectRootPosix)}, {`);
         lines.push('  recursive: true,');
         lines.push(`  regExp: ${includeRegExp.toString()},`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rstest/browser",
-  "version": "0.10.5",
+  "version": "0.10.6",
   "description": "Browser mode support for Rstest testing framework.",
   "keywords": [
     "rstest",
@@ -48,21 +48,21 @@
     "ws": "^8.21.0"
   },
   "devDependencies": {
-    "@rslib/core": "0.22.1",
+    "@rslib/core": "0.23.0",
     "@types/convert-source-map": "^2.0.3",
     "@types/picomatch": "^4.0.3",
     "@types/ws": "^8.18.1",
     "@vitest/snapshot": "^3.2.6",
     "birpc": "^4.0.0",
     "picomatch": "^4.0.4",
-    "playwright": "^1.60.0",
+    "playwright": "^1.61.0",
     "@rstest/browser-ui": "0.0.0",
-    "@rstest/core": "0.10.5",
-    "@rstest/tsconfig": "0.0.1"
+    "@rstest/tsconfig": "0.0.1",
+    "@rstest/core": "0.10.6"
   },
   "peerDependencies": {
     "playwright": "^1.49.1",
-    "@rstest/core": "^0.10.5"
+    "@rstest/core": "^0.10.6"
   },
   "peerDependenciesMeta": {
     "playwright": {

package/src/hostController.ts

@@ -629,6 +629,7 @@ const globToRegexp = (glob: string): RegExp => {
     fastpaths: false,
     noglobstar: false,
     bash: false,
+    dot: true,
   });
 
   if (!regex) {
@@ -676,44 +677,189 @@ const globPatternsToRegExp = (patterns: string[]): RegExp => {
   return new RegExp(`(?:${regexParts.join('|')})$`);
 };
 
+const REGEXP_SPECIAL_CHARACTERS = /[|\\{}()[\]^$+*?.]/g;
+const PATH_SEPARATOR_SOURCE = String.raw`[\\/]`;
+const WINDOWS_ABSOLUTE_PATH_SOURCE = String.raw`[A-Za-z]:[\\/]`;
+
+const escapeRegExp = (value: string): string =>
+  value.replace(REGEXP_SPECIAL_CHARACTERS, '\\$&');
+
+const normalizePathForRegExp = (value: string): string =>
+  normalize(value).replaceAll('\\', '/');
+
+const normalizeExcludePatternForRegExp = (value: string): string =>
+  value.startsWith('./')
+    ? `./${normalizePathForRegExp(value.substring(2))}`
+    : normalizePathForRegExp(value);
+
+const isAbsolutePatternForRegExp = (value: string): boolean =>
+  value.startsWith('/') || /^[A-Za-z]:\//.test(value);
+
+const isEscapedRegExpCharacter = (source: string, index: number): boolean => {
+  let backslashCount = 0;
+  for (
+    let current = index - 1;
+    current >= 0 && source[current] === '\\';
+    current--
+  ) {
+    backslashCount++;
+  }
+  return backslashCount % 2 === 1;
+};
+
+const replacePathSeparatorsInRegExpSource = (source: string): string => {
+  let result = '';
+  let inCharacterClass = false;
+
+  for (let index = 0; index < source.length; index++) {
+    const character = source[index];
+    const isEscaped = isEscapedRegExpCharacter(source, index);
+
+    if (character === '[' && !isEscaped) {
+      inCharacterClass = true;
+    }
+
+    if (!inCharacterClass && character === '\\' && source[index + 1] === '/') {
+      result += PATH_SEPARATOR_SOURCE;
+      index++;
+      continue;
+    }
+
+    result += character;
+
+    if (character === ']' && !isEscaped) {
+      inCharacterClass = false;
+    }
+  }
+
+  return result;
+};
+
+type BrowserContextExcludeSource = {
+  relative: string;
+  absolute: string;
+  isAbsolute: boolean;
+};
+
+const createRelativeContextExcludeSource = (
+  source: string,
+  normalizedPattern: string,
+): string => {
+  if (normalizedPattern.startsWith('./')) {
+    return source;
+  }
+
+  return normalizedPattern.startsWith('**/')
+    ? `(?:(?:${source})|\\.(?:${source}))`
+    : `(?:(?:${source})|\\.${PATH_SEPARATOR_SOURCE}(?:${source}))`;
+};
+
+const createProjectAbsoluteExcludeSource = (
+  source: string,
+  normalizedPattern: string,
+): string =>
+  normalizedPattern.startsWith('./') || normalizedPattern.startsWith('**/')
+    ? source
+    : `${PATH_SEPARATOR_SOURCE}(?:${source})`;
+
 /**
  * Convert exclude patterns to a RegExp for import.meta.webpackContext's exclude option
  * This is used at compile time to filter out files during bundling
  *
  * Example:
  *   Input: ['**\/node_modules\/**', '**\/dist\/**']
- *   Output: /[\\/](node_modules|dist)[\\/]/
+ *   Output: a regexp matching node_modules or dist path segments.
  */
-const excludePatternsToRegExp = (patterns: string[]): RegExp | null => {
-  const keywords: string[] = [];
-  for (const pattern of patterns) {
-    // Extract the core part between ** wildcards
-    // e.g., '**/node_modules/**' -> 'node_modules'
-    // e.g., '**/dist/**' -> 'dist'
-    // e.g., '**/.{idea,git,cache,output,temp}/**' -> extract each part
-    const match = pattern.match(
-      /\*\*\/\.?\{?([^/*{}]+(?:,[^/*{}]+)*)\}?\/?\*?\*?/,
-    );
-    if (match) {
-      // Handle {a,b,c} patterns
-      const parts = match[1]!.split(',');
-      for (const part of parts) {
-        // Clean up the part (remove leading dots for hidden dirs)
-        const cleaned = part.replace(/^\./, '');
-        if (cleaned && !keywords.includes(cleaned)) {
-          keywords.push(cleaned);
-        }
-      }
+const excludePatternsToRegExpSources = (
+  patterns: string[],
+): BrowserContextExcludeSource[] | null => {
+  const sources = patterns.map((pattern) => {
+    const normalizedPattern = normalizeExcludePatternForRegExp(pattern);
+    const regex = globToRegexp(normalizedPattern);
+    let source = regex.source;
+    if (source.startsWith('^')) {
+      source = source.substring(1);
     }
+    if (source.endsWith('$')) {
+      source = source.substring(0, source.length - 1);
+    }
+
+    source = replacePathSeparatorsInRegExpSource(source);
+    const isAbsolute = isAbsolutePatternForRegExp(normalizedPattern);
+    const absolute = normalizedPattern.startsWith('./')
+      ? source.substring(2)
+      : source;
+
+    return {
+      relative: isAbsolute
+        ? source
+        : createRelativeContextExcludeSource(source, normalizedPattern),
+      absolute: isAbsolute
+        ? absolute
+        : createProjectAbsoluteExcludeSource(absolute, normalizedPattern),
+      isAbsolute,
+    };
+  });
+
+  if (sources.length === 0) {
+    return null;
   }
 
-  if (keywords.length === 0) {
+  return sources;
+};
+
+export const createBrowserContextExcludeRegExp = (
+  patterns: string[],
+  projectRoot: string,
+): RegExp | null => {
+  const excludeSources = excludePatternsToRegExpSources(patterns);
+  if (!excludeSources) {
     return null;
   }
 
-  // Create regex that matches paths containing these directory names
-  // Use [\\/] to match both forward and back slashes
-  return new RegExp(`[\\\\/](${keywords.join('|')})[\\\\/]`);
+  const normalizedProjectRoot = normalizePathForRegExp(projectRoot).replace(
+    /[\\/]$/,
+    '',
+  );
+  const projectRootSource = normalizedProjectRoot
+    .split('/')
+    .map(escapeRegExp)
+    .join(PATH_SEPARATOR_SOURCE);
+  const relativeExcludeSources = excludeSources.filter(
+    (source) => !source.isAbsolute,
+  );
+  const absoluteExcludeSources = excludeSources.filter(
+    (source) => source.isAbsolute,
+  );
+  const sourceBranches: string[] = [];
+
+  if (relativeExcludeSources.length > 0) {
+    const relativePatternSource = `(?:${relativeExcludeSources
+      .map((source) => source.relative)
+      .join('|')})`;
+    const absolutePatternSource = `(?:${relativeExcludeSources
+      .map((source) => source.absolute)
+      .join('|')})`;
+    const relativeSource = `(?:${relativePatternSource})`;
+    const absoluteSource = normalizedProjectRoot
+      ? `${projectRootSource}(?=${PATH_SEPARATOR_SOURCE})(?:${absolutePatternSource})`
+      : `(?:${absolutePatternSource})`;
+
+    sourceBranches.push(
+      `(?!${WINDOWS_ABSOLUTE_PATH_SOURCE}|${PATH_SEPARATOR_SOURCE})${relativeSource}`,
+      absoluteSource,
+    );
+  }
+
+  if (absoluteExcludeSources.length > 0) {
+    sourceBranches.push(
+      `(?:${absoluteExcludeSources
+        .map((source) => source.relative)
+        .join('|')})`,
+    );
+  }
+
+  return new RegExp(`^(?:${sourceBranches.join('|')})$`);
 };
 
 type StatsModule = {
@@ -1087,7 +1233,10 @@ const generateManifestModule = ({
       project.normalizedConfig.include,
     );
     const excludePatterns = project.normalizedConfig.exclude.patterns;
-    const excludeRegExp = excludePatternsToRegExp(excludePatterns);
+    const excludeRegExp = createBrowserContextExcludeRegExp(
+      excludePatterns,
+      projectRootPosix,
+    );
 
     lines.push(
       `const ${varName} = import.meta.webpackContext(${JSON.stringify(projectRootPosix)}, {`,