[New] create ignorePrivate option for no-multi-comp rule

docs/rules/no-multi-comp.md

@@ -69,6 +69,55 @@ class HelloJohn extends React.Component {
 module.exports = HelloJohn;
 ```
 
+### `ignorePrivate`
+
+When `true` the rule will ignore components which are not exported, which allows you to define components that are consumed only within the same file.
+This ensures there is only one entry point for a React component without limiting the structural content of the file.
+
+Examples of **correct** code for this rule:
+
+```jsx
+export function Hello(props) {
+  return <div>Hello {props.name}</div>;
+}
+function HelloAgain(props) {
+  return <div>Hello again {props.name}</div>;
+}
+```
+
+```jsx
+function Hello(props) {
+  return <div>Hello {props.name}</div>;
+}
+class HelloJohn extends React.Component {
+  render() {
+    return <Hello name="John" />;
+  }
+}
+module.exports = HelloJohn;
+```
+
+Examples of **incorrect** code for this rule:
+
+```jsx
+export function Hello(props) {
+  return <div>Hello {props.name}</div>;
+}
+export function HelloAgain(props) {
+  return <div>Hello again {props.name}</div>;
+}
+```
+
+```jsx
+function Hello(props) {
+  return <div>Hello {props.name}</div>;
+}
+function HelloAgain(props) {
+  return <div>Hello again {props.name}</div>;
+}
+module.exports = {Hello, HelloAgain}
+```
+
 ## When Not To Use It
 
 If you prefer to declare multiple components per file you can disable this rule.

lib/rules/no-multi-comp.js

@@ -17,6 +17,7 @@ const report = require('../util/report');
 
 const messages = {
   onlyOneComponent: 'Declare only one React component per file',
+  onlyOneExportedComponent: 'Declare only one exported React component per file',
 };
 
 /** @type {import('eslint').Rule.RuleModule} */
@@ -38,6 +39,10 @@ module.exports = {
           default: false,
           type: 'boolean',
         },
+        ignorePrivate: {
+          default: false,
+          type: 'boolean',
+        },
       },
       additionalProperties: false,
     }],
@@ -46,6 +51,43 @@ module.exports = {
   create: Components.detect((context, components, utils) => {
     const configuration = context.options[0] || {};
     const ignoreStateless = configuration.ignoreStateless || false;
+    const ignorePrivate = configuration.ignorePrivate || false;
+
+    const exportedComponents = new Set(); // Track exported components
+    const validIdentifiers = new Set(['ArrowFunctionExpression', 'Identifier', 'FunctionExpression']);
+
+    /**
+     * Given an export declaration, find the export name.
+     * @param {Object} node
+     * @returns {string}
+     */
+    function getExportedComponentName(node) {
+      if (node.declaration.type === 'ClassDeclaration') {
+        return node.declaration.id.name;
+      }
+      for (const declarator of node.declaration.declarations || []) {
+        const type = declarator.init.type;
+        if (validIdentifiers.has(type)) {
+          return declarator.id.name;
+        }
+      }
+    }
+
+    /**
+     * Given a React component, find the exported name.
+     * @param {Object} component
+     * @returns {string}
+     */
+    function findComponentIdentifierFromComponent(component) {
+      let name;
+      if (component.node.parent.id) {
+        name = component.node.parent.id.name;
+      }
+      if (!name) {
+        name = component.node.id.name;
+      }
+      return name;
+    }
 
     /**
      * Checks if the component is ignored
@@ -61,21 +103,46 @@ module.exports = {
       );
     }
 
-    return {
+    /**
+     * Checks if the component is exported, if exportOnly is set
+     * @param {Object} component The component being checked.
+     * @returns {boolean} True if the component is exported or exportOnly is false
+     */
+    function isPrivate(component) {
+      return ignorePrivate && exportedComponents.has(findComponentIdentifierFromComponent(component));
+    }
+
+    const rule = {
       'Program:exit'() {
         if (components.length() <= 1) {
           return;
         }
 
         values(components.list())
           .filter((component) => !isIgnored(component))
+          .filter((component) => !isPrivate(component))
           .slice(1)
           .forEach((component) => {
-            report(context, messages.onlyOneComponent, 'onlyOneComponent', {
-              node: component.node,
-            });
+            report(context,
+              ignorePrivate ? messages.onlyOneExportedComponent : messages.onlyOneComponent,
+              ignorePrivate ? 'onlyOneExportedComponent' : 'onlyOneComponent',
+              {
+                node: component.node,
+              });
           });
       },
     };
+
+    if (ignorePrivate) {
+      rule.ExportNamedDeclaration = (node) => {
+        exportedComponents.add(getExportedComponentName(node));
+      };
+
+      rule.ExportDefaultDeclaration = (node) => {
+        exportedComponents.add(getExportedComponentName(node));
+      };
+    }
+
+    return rule;
   }),
 };