Ignore Warnings: Strip ANSI Color Codes In Rspack

Hey there, web dev wizards! Ever pulled your hair out trying to get Rspack to play nice with your ignoreWarnings config, only to find out it's still spitting out messages you specifically told it to keep quiet? Yeah, us too. It's like Rspack's being a bit too helpful by adding those fancy ANSI color codes to your warnings, making your carefully crafted ignore rules go totally haywire. Well, guys, get ready for some good news because we've tackled this pesky issue, and it's going to make your build process a whole lot smoother. Let's dive into why this has been a headache and how we've fixed it, making your ignoreWarnings actually work the way you intend them to.

The Nitty-Gritty: Why ANSI Codes Were Ruining Your Warnings

So, the core of the problem is pretty simple but super annoying: Rspack, by default, likes to jazz up console output with ANSI escape codes. These codes are what give you that nice, colored text in your terminal – think yellow for warnings, red for errors, you know the drill. The ignoreWarnings option in Rspack is designed to be your trusty sidekick, helping you filter out those noisy, repetitive, or just plain irrelevant warnings that clutter up your build logs. You typically set it up thinking about the plain text of the warning message, right? It's way more intuitive to think, "Okay, I want to ignore warnings about 'moment' not being resolvable," rather than trying to guess what specific color codes are wrapped around the word 'moment'.

However, when Rspack injects those ANSI color codes directly into the warning messages, your ignoreWarnings patterns suddenly start failing. If you've written a rule like /Can't resolve 'moment'/, it works perfectly fine unless 'moment' is colorized. Then, the actual message Rspack sees isn't just /Can't resolve 'moment'/; it's something way more complex, like /Can't resolve \[33m'moment'\[39m/ (that \[33m and \[39m are the ANSI codes for yellow and reset, respectively). Your simple pattern is looking for plain text, but it's getting a string with hidden control characters, and poof – your warning appears, much to your frustration.

We've seen this firsthand. Imagine you have an optional dependency, and Rspack happily warns you every single time it can't find it. Totally expected behavior, so you want to ignore it. You set up your ignoreWarnings like this:

// This is what you *wanted* to do...
ignoreWarnings: [
  /Can't resolve 'moment'/
  // Or even more explicitly:
  { message: /Can't resolve 'moment'/ }
]

But then, the warning stubbornly persists. Why? Because the actual message Rspack is processing looks something like this (when debugged):

// What Rspack is *actually* seeing:
'\u001b[33mCan\'t resolve \'moment\'\u001b[39m'

To get it to work, you'd have to resort to some arcane regex that explicitly includes those ANSI escape codes, like /Can't resolve \x1B\[33m'moment'\x1B\[39m/. That's just not practical, guys. It's brittle, hard to read, and frankly, a terrible developer experience. It forces you to inspect the raw output, decipher the escape codes, and write complex patterns that are tied to the display rather than the content of the message. This has been a known issue, leading to discussions and bug reports (like the ones linked in the original description) because it directly impacts the usability of a core feature.

The Brilliant Solution: Automatic ANSI Stripping!

Now, for the really awesome part. We've implemented a feature that automatically strips these ANSI color codes from warning messages before they are matched against your ignoreWarnings patterns. That's right, no more manual guesswork, no more digging into escape codes. Rspack will now intelligently clean up the message, giving your ignoreWarnings configuration a clean, plain-text version to work with. This means your original, intuitive patterns will just work, plain and simple.

So, going back to our example, that ignoreWarnings configuration you wrote earlier?

// Now, this will actually work!
ignoreWarnings: [
  /Can't resolve 'moment'/
  { message: /Can't resolve 'moment'/ }
]

This configuration will now correctly ignore the warning, even if Rspack would have otherwise colorized the message. The ignoreWarnings option will receive a clean string like 'Can't resolve 'moment'', allowing your simple, human-readable regex to match as intended. This change is huge because it aligns the input Rspack uses for filtering with how developers naturally think about text and error messages. It removes a significant layer of indirection and potential for user error, making the build process more predictable and easier to manage.

What does this mean for you?

• Simpler Configuration: Write your ignoreWarnings rules using plain text patterns. No need to worry about terminal color codes anymore.
• Increased Reliability: Your ignoreWarnings rules will now work consistently, as intended.
• Better Developer Experience: Spend less time debugging warning suppression and more time building awesome things.

This enhancement directly addresses the core problem where the ignoreWarnings configuration didn't align with the actual output received by the user. By ensuring that the patterns are matched against the unstyled warning message, Rspack is now much more user-friendly and predictable. This is a fundamental improvement that will save countless hours of frustration for developers working with Rspack. We believe in making tools that empower developers, and this is a significant step in that direction.

No Configuration Changes Needed – Just Smoother Builds!

One of the best parts about this new feature? You don't need to change a single line of your existing Rspack configuration! Seriously. This enhancement is applied automatically under the hood. Rspack will now internally process your warning messages, strip out any ANSI color codes, and then compare the cleaned-up message against your ignoreWarnings patterns. This means that if you had a warning that wasn't being ignored because of color codes, it will now be ignored automatically without you lifting a finger. It's a seamless improvement that just makes things work better.

This