feat: add excludeErrorLogs option (#18)

Co-authored-by: zhengxiaorui.1234 <[email protected]>
Co-authored-by: neverland <[email protected]>

Author: 3 people

README.md

@@ -176,6 +176,23 @@ pluginCheckSyntax({
 });
 ```
 
+### excludeErrorLogs
+
+- **Type:** `('source' | 'output' | 'reason' | 'code')[]`
+- **Default:** `[]`
+
+`excludeErrorLogs` is used to ignore specified syntax error messages after detection. You can pass in one or more error message types to ignore.
+
+- **Example:**
+
+For example, to ignore the reason and code displayed in the terminal.
+
+```ts
+pluginCheckSyntax({
+  excludeErrorLogs: ["reason", "code"],
+});
+```
+
 ## Limitations
 
 1. Check Syntax plugin only checks incompatible syntax in the outputs and cannot detect missing polyfills.

package.json

@@ -14,9 +14,7 @@
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
   "scripts": {
     "build": "rslib build",
     "dev": "rslib build --watch",

src/CheckSyntaxPlugin.ts

@@ -40,7 +40,7 @@ export class CheckSyntaxRspackPlugin extends CheckSyntax {
           }),
         );
 
-        printErrors(this.errors, this.ecmaVersion);
+        printErrors(this.errors, this.ecmaVersion, this.excludeErrorLogs);
       },
     );
   }

src/checkSyntax.ts

@@ -9,6 +9,7 @@ import type {
   CheckSyntaxOptions,
   ECMASyntaxError,
   EcmaVersion,
+  SyntaxErrorKey,
 } from './types.js';
 import { checkIsExclude } from './utils.js';
 
@@ -28,6 +29,8 @@ export class CheckSyntax {
 
   excludeOutput: CheckSyntaxExclude | undefined;
 
+  excludeErrorLogs: SyntaxErrorKey[];
+
   constructor(
     options: CheckSyntaxOptions &
       Required<Pick<CheckSyntaxOptions, 'targets'>> & {
@@ -40,6 +43,7 @@ export class CheckSyntax {
     this.rootPath = options.rootPath;
     this.ecmaVersion =
       options.ecmaVersion || browserslistToESVersion(this.targets);
+    this.excludeErrorLogs = options.excludeErrorLogs || [];
   }
 
   async check(filepath: string, code?: string) {

src/printErrors.ts

@@ -1,24 +1,23 @@
 import { logger } from '@rsbuild/core';
 import color from 'picocolors';
-import type { ECMASyntaxError, EcmaVersion } from './types.js';
-
-type Error = {
-  source: string;
-  output?: string;
-  reason: string;
-  code: string;
-};
+import type {
+  ECMASyntaxError,
+  EcmaVersion,
+  SyntaxErrorInfo,
+  SyntaxErrorKey,
+} from './types.js';
 
 export function printErrors(
   errors: ECMASyntaxError[],
   ecmaVersion: EcmaVersion,
+  excludeErrorLogs: SyntaxErrorKey[],
 ): void {
   if (errors.length === 0) {
     logger.success('[@rsbuild/plugin-check-syntax] Syntax check passed.');
     return;
   }
 
-  const errs: Error[] = errors.map((error) => ({
+  const errs: SyntaxErrorInfo[] = errors.map((error) => ({
     source: `${error.source.path}:${error.source.line}:${error.source.column}`,
     output: error.output
       ? `${error.output.path}:${error.output.line}:${error.output.column}`
@@ -36,7 +35,7 @@ export function printErrors(
 
   errs.forEach((err, index) => {
     console.log(color.bold(color.red(`  ERROR ${index + 1}`)));
-    printMain(err, longest);
+    printMain(err, longest, excludeErrorLogs);
   });
 
   throw new Error(
@@ -48,7 +47,11 @@ export function printErrors(
   );
 }
 
-function printMain(error: Error, longest: number) {
+function printMain(
+  error: SyntaxErrorInfo,
+  longest: number,
+  excludeErrorLogs: SyntaxErrorKey[],
+) {
   const fillWhiteSpace = (s: string, longest: number) => {
     if (s.length < longest) {
       const rightPadding = ' '.repeat(longest - s.length);
@@ -58,7 +61,7 @@ function printMain(error: Error, longest: number) {
   };
 
   for (const [key, content] of Object.entries(error)) {
-    if (!content) {
+    if (!content || excludeErrorLogs.includes(key as SyntaxErrorKey)) {
       continue;
     }
     const title = color.magenta(`${fillWhiteSpace(`${key}:`, longest + 1)}`);

src/types.ts

@@ -25,6 +25,11 @@ export type CheckSyntaxOptions = {
    * The priority of `ecmaVersion` is higher than `targets`.
    */
   ecmaVersion?: EcmaVersion;
+  /**
+   * Used to ignore specified syntax error messages after detection.
+   * You can pass in one or more error message types to ignore.
+   */
+  excludeErrorLogs?: SyntaxErrorKey[];
 };
 
 export interface Location {
@@ -60,3 +65,12 @@ export type AcornParseError = {
   pos: number;
   loc: Location;
 };
+
+export type SyntaxErrorInfo = {
+  source: string;
+  output?: string;
+  reason: string;
+  code: string;
+};
+
+export type SyntaxErrorKey = keyof SyntaxErrorInfo;

test/esnext/index.test.ts

@@ -106,3 +106,34 @@ test('should not throw error when using optional chaining and ecmaVersion is 202
 
   await expect(rsbuild.build()).resolves.toBeTruthy();
 });
+
+test('should allow to exclude the output and reason details from the error message.', async () => {
+  const { logs, restore } = proxyConsole();
+
+  const rsbuild = await createRsbuild({
+    cwd: __dirname,
+    rsbuildConfig: {
+      ...(await loadConfig({ cwd: __dirname })).content,
+      plugins: [
+        pluginCheckSyntax({
+          targets: ['chrome >= 53'],
+          excludeErrorLogs: ['source', 'output', 'reason', 'code'],
+        }),
+      ],
+    },
+  });
+
+  await expect(rsbuild.build()).rejects.toThrowError(
+    '[@rsbuild/plugin-check-syntax]',
+  );
+
+  restore();
+
+  expect(logs.find((log) => log.includes('ERROR 1'))).toBeTruthy();
+  expect(logs.find((log) => log.includes('source:'))).toBeFalsy();
+  expect(logs.find((log) => log.includes('output:'))).toBeFalsy();
+  expect(logs.find((log) => log.includes('reason:'))).toBeFalsy();
+  expect(
+    logs.find((log) => log.includes('> 3 |   console.log(arr, arr?.flat());')),
+  ).toBeFalsy();
+});