feat: add restrictedNamedExportsPattern to no-restricted-exports

docs/src/rules/no-restricted-exports.md

@@ -17,6 +17,7 @@ By default, this rule doesn't disallow any names. Only the names you specify in
 This rule has an object option:
 
 * `"restrictedNamedExports"` is an array of strings, where each string is a name to be restricted.
+* `"restrictedNamedExportsPattern"` is an array of regex strings, where each string regex pattern would be restricted.
 * `"restrictDefaultExports"` is an object option with boolean properties to restrict certain default export declarations. The option works only if the `restrictedNamedExports` option does not contain the `"default"` value. The following properties are allowed:
     * `direct`: restricts `export default` declarations.
     * `named`: restricts `export { foo as default };` declarations.
@@ -130,6 +131,20 @@ export default function foo() {}
 
 :::
 
+### restrictedNamedExportsPattern
+
+This option allows you to restrict regex patterns for named exports.
+
+```js
+/*eslint no-restricted-exports: ["error", {
+    "restrictedNamedExports": [],
+    "restrictedNamedExportsPattern": ["^privateUser"]
+}]*/
+
+var privateUserEmail = '...'; 
+export { privateUserEmail };
+```
+
 ### restrictDefaultExports
 
 This option allows you to restrict certain `default` declarations. The option works only if the `restrictedNamedExports` option does not contain the `"default"` value. This option accepts the following properties:

lib/rules/no-restricted-exports.js

@@ -41,6 +41,26 @@ module.exports = {
                     },
                     additionalProperties: false
                 },
+                {
+                    type: "object",
+                    properties: {
+                        restrictedNamedExports: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            },
+                            uniqueItems: true
+                        },
+                        restrictedNamedExportsPattern: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            },
+                            uniqueItems: true
+                        }
+                    },
+                    additionalProperties: false
+                },
                 {
                     type: "object",
                     properties: {
@@ -98,6 +118,7 @@ module.exports = {
     create(context) {
 
         const restrictedNames = new Set(context.options[0] && context.options[0].restrictedNamedExports);
+        const restrictedNamePatterns = new Set(context.options[0] && context.options[0].restrictedNamedExportsPattern || []);
         const restrictDefaultExports = context.options[0] && context.options[0].restrictDefaultExports;
         const sourceCode = context.sourceCode;
 
@@ -109,7 +130,13 @@ module.exports = {
         function checkExportedName(node) {
             const name = astUtils.getModuleExportName(node);
 
-            if (restrictedNames.has(name)) {
+            const hasRestrictedNamePattern = [...restrictedNamePatterns].some(pattern => {
+                const patternRegex = new RegExp(pattern, "u");
+
+                return name && patternRegex.test(name);
+            });
+
+            if (hasRestrictedNamePattern || restrictedNames.has(name)) {
                 context.report({
                     node,
                     messageId: "restrictedNamed",

tests/lib/rules/no-restricted-exports.js

@@ -91,6 +91,10 @@ ruleTester.run("no-restricted-exports", rule, {
         { code: "import a from 'foo';", options: [{ restrictedNamedExports: ["a"] }] },
         { code: "import { a } from 'foo';", options: [{ restrictedNamedExports: ["a"] }] },
         { code: "import { b as a } from 'foo';", options: [{ restrictedNamedExports: ["a"] }] },
+        {
+            code: "var setSomething; export { setSomething };",
+            options: [{ restrictedNamedExportsPattern: ["^get"] }]
+        },
 
         // does not check re-export all declarations
         { code: "export * from 'foo';", options: [{ restrictedNamedExports: ["a"] }] },
@@ -533,6 +537,44 @@ ruleTester.run("no-restricted-exports", rule, {
             ]
         },
 
+        // restrictedNamedExportsPattern
+        {
+            code: "var getSomething; export { getSomething };",
+            options: [{ restrictedNamedExportsPattern: ["get*"] }],
+            errors: [
+                { messageId: "restrictedNamed", data: { name: "getSomething" }, type: "Identifier" }
+            ]
+        },
+        {
+            code: "var getSomethingFromUser; export { getSomethingFromUser };",
+            options: [{ restrictedNamedExportsPattern: ["User$"] }],
+            errors: [
+                { messageId: "restrictedNamed", data: { name: "getSomethingFromUser" }, type: "Identifier" }
+            ]
+        },
+        {
+            code: "var foo, ab, xy; export { foo, ab, xy };",
+            options: [{ restrictedNamedExportsPattern: ["(b|y)$"] }],
+            errors: [
+                { messageId: "restrictedNamed", data: { name: "ab" }, type: "Identifier" },
+                { messageId: "restrictedNamed", data: { name: "xy" }, type: "Identifier" }
+            ]
+        },
+        {
+            code: "var foo; export { foo as ab };",
+            options: [{ restrictedNamedExportsPattern: ["(b|y)$"] }],
+            errors: [
+                { messageId: "restrictedNamed", data: { name: "ab" }, type: "Identifier" }
+            ]
+        },
+        {
+            code: "var privateUserEmail; export { privateUserEmail };",
+            options: [{ restrictedNamedExportsPattern: ["^privateUser"] }],
+            errors: [
+                { messageId: "restrictedNamed", data: { name: "privateUserEmail" }, type: "Identifier" }
+            ]
+        },
+
         // reports "default" in named export declarations (when configured)
         {
             code: "var a; export { a as default };",