CHANGELOG has been changed

CHANGELOG.md

@@ -15,6 +15,10 @@ Our versioning strategy is as follows:
 
 * `[nextjs][sitecore-jss-nextjs]` Support for Component Library feature in XMCloud ([#1987](https://github.com/Sitecore/jss/pull/1987))
 
+### 🐛 Bug Fixes
+
+* `[sitecore-jss-nextjs]` Fixed handling of ? inside square brackets [] in regex patterns to prevent incorrect escaping ([#1999](https://github.com/Sitecore/jss/pull/1999))
+
 ## 22.3.0 / 22.3.1
 
 ### 🐛 Bug Fixes

packages/sitecore-jss-nextjs/src/middleware/redirects-middleware.ts

@@ -200,7 +200,9 @@ export class RedirectsMiddleware extends MiddlewareBase {
       ? modifyRedirects.find((redirect: RedirectInfo & { matchedQueryString?: string }) => {
           // Modify the redirect pattern to ignore the language prefix in the path
           // And escapes non-special "?" characters in a string or regex.
-          redirect.pattern = this.escapeNonSpecialQuestionMarks(redirect.pattern.replace(RegExp(`^[^]?/${language}/`, 'gi'), ''));
+          redirect.pattern = this.escapeNonSpecialQuestionMarks(
+            redirect.pattern.replace(RegExp(`^[^]?/${language}/`, 'gi'), '')
+          );
 
           // Prepare the redirect pattern as a regular expression, making it more flexible for matching URLs
           redirect.pattern = `/^\/${redirect.pattern
@@ -365,9 +367,9 @@ export class RedirectsMiddleware extends MiddlewareBase {
 
   /**
    * Escapes non-special "?" characters in a string or regex.
-   * 
+   *
    * - For regular strings, it escapes all unescaped "?" characters by adding a backslash (`\`).
-   * - For regex patterns (strings enclosed in `/.../`), it analyzes each "?" to determine if it has special meaning 
+   * - For regex patterns (strings enclosed in `/.../`), it analyzes each "?" to determine if it has special meaning
    *   (e.g., `?` in `(abc)?`, `.*?`) or is just a literal character. Only literal "?" characters are escaped.
    * @param {string} input - The input string or regex pattern.
    * @returns {string} - The modified string or regex with non-special "?" characters escaped.
@@ -377,8 +379,8 @@ export class RedirectsMiddleware extends MiddlewareBase {
     const isRegex = input.startsWith('/') && input.endsWith('/'); // Check if the string is a regex
 
     if (!isRegex) {
-        // If not a regex, escape all unescaped "?" characters
-        return input.replace(regexPattern, '\\?');
+      // If not a regex, escape all unescaped "?" characters
+      return input.replace(regexPattern, '\\?');
     }
 
     // If it's a regex, analyze each "?" character
@@ -387,21 +389,21 @@ export class RedirectsMiddleware extends MiddlewareBase {
 
     let match;
     while ((match = regexPattern.exec(input)) !== null) {
-        const index = match.index; // Position of "?" in the string
-        const before = input.slice(0, index).replace(/\s+$/, ''); // Context before "?"
-        const lastChar = before.slice(-1); // Last character before "?"
+      const index = match.index; // Position of "?" in the string
+      const before = input.slice(0, index).replace(/\s+$/, ''); // Context before "?"
+      const lastChar = before.slice(-1); // Last character before "?"
 
-        // Determine if the "?" is a special regex symbol
-        const isSpecialRegexSymbol = /[\.\*\+\)\[\]]$/.test(lastChar);
+      // Determine if the "?" is a special regex symbol
+      const isSpecialRegexSymbol = /[\.\*\+\)\[\]]$/.test(lastChar);
 
-        if (isSpecialRegexSymbol) {
-            // If it's special, keep it as is
-            result += input.slice(lastIndex, index + 1);
-        } else {
-            // If it's not special, escape it
-            result += input.slice(lastIndex, index) + '\\?';
-        }
-        lastIndex = index + 1;
+      if (isSpecialRegexSymbol) {
+        // If it's special, keep it as is
+        result += input.slice(lastIndex, index + 1);
+      } else {
+        // If it's not special, escape it
+        result += input.slice(lastIndex, index) + '\\?';
+      }
+      lastIndex = index + 1;
     }
 
     // Append the remaining part of the string