feat: extend exclude condition support to include strings and functions (#49)

Author: chenjiahan

README.md

@@ -166,7 +166,13 @@ At this time, the build artifacts can include all syntax supported by ES2020, su
 
 ### exclude
 
-- **Type:** `RegExp | RegExp[]`
+- **Type:**
+
+```ts
+type Condition = string | RegExp | ((filepath: string) => boolean);
+type Exclude = Condition | Condition[];
+```
+
 - **Default:** `undefined`
 
 Excludes a portion of source files during detection. You can pass in one or more regular expressions to match the paths of source files. Files that match the regular expression will be ignored and will not trigger syntax checking.
@@ -181,9 +187,33 @@ pluginCheckSyntax({
 });
 ```
 
+Or pass in a function to match the paths of source files. Files that return true when the function is called will be ignored:
+
+```ts
+pluginCheckSyntax({
+  exclude: (filepath) => filepath.includes("node_modules/foo"),
+});
+```
+
+Or passing an absolute path to match the paths of source files. Files that match the absolute path will be ignored:
+
+```ts
+import path from "node:path";
+
+pluginCheckSyntax({
+  exclude: path.posix.join(__dirname, "node_modules/foo"),
+});
+```
+
 ### excludeOutput
 
-- **Type:** `RegExp | RegExp[]`
+- **Type:**
+
+```ts
+type Condition = string | RegExp | ((filepath: string) => boolean);
+type Exclude = Condition | Condition[];
+```
+
 - **Default:** `undefined`
 
 Excludes a portion of output files before detection. You can pass in one or more regular expressions to match the paths of output files. Files that match the regular expression will be ignored and will not trigger syntax checking.

src/CheckSyntaxPlugin.ts

@@ -2,7 +2,7 @@ import { resolve } from 'node:path';
 import type { Rspack } from '@rsbuild/core';
 import { CheckSyntax } from './checkSyntax.js';
 import { printErrors } from './printErrors.js';
-import { isPathExcluded } from './utils.js';
+import { isExcluded } from './utils.js';
 
 type Compiler = Rspack.Compiler;
 type Compilation = Rspack.Compilation;
@@ -29,7 +29,7 @@ export class CheckSyntaxRspackPlugin extends CheckSyntax {
             // remove query from name
             const resourcePath = a.name.split('?')[0];
             const file = resolve(outputPath, resourcePath);
-            if (isPathExcluded(file, this.excludeOutput)) {
+            if (isExcluded(file, this.excludeOutput)) {
               return '';
             }
             return file;

src/checkSyntax.ts

@@ -11,7 +11,7 @@ import type {
   EcmaVersion,
   SyntaxErrorKey,
 } from './types.js';
-import { isPathExcluded } from './utils.js';
+import { isExcluded } from './utils.js';
 
 const HTML_REGEX = /\.html$/;
 export const JS_REGEX: RegExp = /\.(?:js|mjs|cjs|jsx)$/;
@@ -72,7 +72,7 @@ export class CheckSyntax {
       const htmlScripts = await generateHtmlScripts(filepath);
       await Promise.all(
         htmlScripts.map(async (script) => {
-          if (!isPathExcluded(filepath, this.exclude)) {
+          if (!isExcluded(filepath, this.exclude)) {
             await this.tryParse(filepath, script);
           }
         }),

src/generateError.ts

@@ -1,12 +1,13 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import color from 'picocolors';
 import { SourceMapConsumer } from 'source-map';
 import {
   type AcornParseError,
   type CheckSyntaxExclude,
   ECMASyntaxError,
 } from './types.js';
-import { isExcluded, isPathExcluded } from './utils.js';
+import { isExcluded } from './utils.js';
 
 export function displayCodePointer(code: string, pos: number) {
   const SUB_LEN = 80;
@@ -36,6 +37,7 @@ export async function generateError({
   let error = await tryGenerateErrorFromSourceMap({
     err,
     code,
+    rootPath,
     outputFilepath: filepath,
     relativeOutputPath,
   });
@@ -44,14 +46,15 @@ export async function generateError({
     error = new ECMASyntaxError(err.message, {
       source: {
         path: relativeOutputPath,
+        absolutePath: filepath,
         line: err.loc.line,
         column: err.loc.column,
         code: displayCodePointer(code, err.pos),
       },
     });
   }
 
-  if (isPathExcluded(error.source.path, exclude)) {
+  if (isExcluded(error.source.absolutePath, exclude)) {
     return null;
   }
 
@@ -80,14 +83,25 @@ export function makeCodeFrame(lines: string[], highlightIndex: number) {
   return `\n${ret.join('\n')}`;
 }
 
+/**
+ * Extract resource path from Rspack's devtoolModuleFilenameTemplate
+ * "resource-path" in "webpack://[namespace]/[resource-path]?[loaders]"
+ */
+function extractResourcePath(source: string) {
+  const match = source.match(/^webpack:\/\/(?:(?:[^/]+)\/)?([^?]+)(?:\?.*)?$/);
+  return match?.[1] || source;
+}
+
 async function tryGenerateErrorFromSourceMap({
   err,
   code,
+  rootPath,
   outputFilepath,
   relativeOutputPath,
 }: {
   err: AcornParseError;
   code: string;
+  rootPath: string;
   outputFilepath: string;
   relativeOutputPath: string;
 }): Promise<ECMASyntaxError | null> {
@@ -113,12 +127,14 @@ async function tryGenerateErrorFromSourceMap({
     const sourceIndex = sources.indexOf(mappedPosition.source);
     const sourceContent: string | null =
       JSON.parse(sourcemap).sourcesContent?.[sourceIndex];
-    const sourcePath = mappedPosition.source.replace(/webpack:\/\/(tmp)?/g, '');
+    const sourcePath = extractResourcePath(mappedPosition.source);
+    const absoluteSourcePath = path.join(rootPath, sourcePath);
 
     if (!sourceContent) {
       return new ECMASyntaxError(err.message, {
         source: {
           path: sourcePath,
+          absolutePath: absoluteSourcePath,
           line: mappedPosition.line ?? 0,
           column: mappedPosition.column ?? 0,
           code: displayCodePointer(code, err.pos),
@@ -137,6 +153,7 @@ async function tryGenerateErrorFromSourceMap({
     return new ECMASyntaxError(err.message, {
       source: {
         path: sourcePath,
+        absolutePath: absoluteSourcePath,
         line: mappedPosition.line ?? 0,
         column: mappedPosition.column ?? 0,
         code: makeCodeFrame(rawLines, highlightLine),

src/types.ts

@@ -2,7 +2,9 @@ import type { ecmaVersion as EcmaVersion } from 'acorn';
 
 export type { EcmaVersion };
 
-export type CheckSyntaxExclude = RegExp | RegExp[];
+export type Condition = string | RegExp | ((filepath: string) => boolean);
+
+export type CheckSyntaxExclude = Condition | Condition[];
 
 export type CheckSyntaxOptions = {
   /**
@@ -24,7 +26,7 @@ export type CheckSyntaxOptions = {
    * Excludes specified error messages.
    * You can pass in one or more regular expressions to match the reasons.
    */
-  excludeErrorMessage?: CheckSyntaxExclude;
+  excludeErrorMessage?: RegExp | RegExp[];
   /**
    * Ignores specified syntax error messages after detection.
    * You can pass in one or more error message types to ignore.
@@ -48,13 +50,15 @@ export interface File {
   column: number;
 }
 
+type Source = File & { code: string } & { absolutePath: string };
+
 interface SyntaxErrorOptions {
-  source: File & { code: string };
+  source: Source;
   output?: File;
 }
 
 export class ECMASyntaxError extends Error {
-  source: File & { code: string };
+  source: Source;
 
   output: File | undefined;
 

src/utils.ts

@@ -4,15 +4,18 @@ export const isExcluded = (input: string, exclude?: CheckSyntaxExclude) => {
   if (!exclude) {
     return false;
   }
+
   const excludes = Array.isArray(exclude) ? exclude : [exclude];
-  return excludes.some((reg) => reg.test(input));
-};
+  // normalize to posix path for RegExp
+  const normalizedPath = input.replace(/\\/g, '/');
 
-export function isPathExcluded(
-  path: string,
-  exclude?: CheckSyntaxExclude,
-): boolean {
-  // normalize to posix path
-  const normalizedPath = path.replace(/\\/g, '/');
-  return isExcluded(normalizedPath, exclude);
-}
+  return excludes.some((condition) => {
+    if (typeof condition === 'function') {
+      return condition(input);
+    }
+    if (typeof condition === 'string') {
+      return input.startsWith(condition);
+    }
+    return condition.test(normalizedPath);
+  });
+};

test/rsbuild-basic/index.test.ts

@@ -1,9 +1,9 @@
-import { dirname } from 'node:path';
+import path, { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createRsbuild, loadConfig, mergeRsbuildConfig } from '@rsbuild/core';
 import { expect, test } from '@rstest/core';
 import stripAnsi from 'strip-ansi';
-import { pluginCheckSyntax } from '../../dist';
+import { pluginCheckSyntax } from '../../src';
 import { normalizeToPosixPath, proxyConsole } from '../helper';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -92,7 +92,7 @@ test('should check assets with query correctly', async () => {
   ).toBeTruthy();
 });
 
-test('should not throw error when the source file is excluded', async () => {
+test('should not throw error when the source file is excluded via RegExp', async () => {
   const rsbuild = await createRsbuild({
     cwd: __dirname,
     rsbuildConfig: {
@@ -108,6 +108,38 @@ test('should not throw error when the source file is excluded', async () => {
   await expect(rsbuild.build()).resolves.toBeTruthy();
 });
 
+test('should not throw error when the source file is excluded via function', async () => {
+  const rsbuild = await createRsbuild({
+    cwd: __dirname,
+    rsbuildConfig: {
+      ...(await loadConfig({ cwd: __dirname })).content,
+      plugins: [
+        pluginCheckSyntax({
+          exclude: (filepath) => /src[\\/]test\.js/.test(filepath),
+        }),
+      ],
+    },
+  });
+
+  await expect(rsbuild.build()).resolves.toBeTruthy();
+});
+
+test('should not throw error when the source file is excluded via string', async () => {
+  const rsbuild = await createRsbuild({
+    cwd: __dirname,
+    rsbuildConfig: {
+      ...(await loadConfig({ cwd: __dirname })).content,
+      plugins: [
+        pluginCheckSyntax({
+          exclude: path.join(__dirname, 'src/test.js'),
+        }),
+      ],
+    },
+  });
+
+  await expect(rsbuild.build()).resolves.toBeTruthy();
+});
+
 test('should not throw error when the output file is excluded', async () => {
   const rsbuild = await createRsbuild({
     cwd: __dirname,