eslint-plugin-primer-react 8.2.0-rc.b646af2 → 8.2.0

package/CHANGELOG.md

@@ -6,6 +6,10 @@
 
 - [#407](https://github.com/primer/eslint-plugin-primer-react/pull/407) [`2f25480`](https://github.com/primer/eslint-plugin-primer-react/commit/2f25480c3341c1d1afb6fc040c5c5deee416d71c) Thanks [@jonrohan](https://github.com/jonrohan)! - Make `use-styled-react-import` rule configurable
 
+### Patch Changes
+
+- [#406](https://github.com/primer/eslint-plugin-primer-react/pull/406) [`d72e8c4`](https://github.com/primer/eslint-plugin-primer-react/commit/d72e8c4c172d1c37da201a20cde0b7b2bd9ab283) Thanks [@jonrohan](https://github.com/jonrohan)! - Fixes for `use-styled-react-import` rule for compound components.
+
 ## 8.1.0
 
 ### Minor Changes

package/docs/rules/use-styled-react-import.md

@@ -12,7 +12,7 @@ Enforce importing components that use `sx` prop from `@primer/styled-react` inst
 
 This rule detects when certain Primer React components are used with the `sx` prop and ensures they are imported from the temporary `@primer/styled-react` package instead of `@primer/react`. When the same components are used without the `sx` prop, it ensures they are imported from `@primer/react` instead of `@primer/styled-react`.
 
-When a component is used both with and without the `sx` prop in the same file, the rule will import the styled version with an alias (e.g., `StyledButton`) and update the JSX usage accordingly to avoid naming conflicts.
+When a component is used with the `sx` prop anywhere in the file, the entire component import is moved to `@primer/styled-react`, simplifying the import structure.
 
 It also moves certain types and utilities to the styled-react package.
 
@@ -111,12 +111,11 @@ const Component = () => <Button>Click me</Button>
 ```
 
 ```jsx
-// When a component is used both ways, use an alias for the styled version
-import {Button} from '@primer/react'
-import {Button as StyledButton} from '@primer/styled-react'
+// When a component is used with sx prop anywhere, import from styled-react
+import {Button} from '@primer/styled-react'
 
 const Component1 = () => <Button>Click me</Button>
-const Component2 = () => <StyledButton sx={{color: 'red'}}>Styled me</StyledButton>
+const Component2 = () => <Button sx={{color: 'red'}}>Styled me</Button>
 ```
 
 ## Options

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-primer-react",
-  "version": "8.2.0-rc.b646af2",
+  "version": "8.2.0",
   "description": "ESLint rules for Primer React",
   "main": "src/index.js",
   "engines": {
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "@styled-system/props": "^5.1.5",
-    "@typescript-eslint/utils": "8.43.0",
+    "@typescript-eslint/utils": "^8.39.0",
     "eslint-plugin-github": "^6.0.0",
     "eslint-plugin-jsx-a11y": "^6.7.1",
     "eslint-traverse": "^1.0.0",

package/src/rules/__tests__/use-styled-react-import.test.js

@@ -56,6 +56,48 @@ ruleTester.run('use-styled-react-import', rule, {
       ],
     },
 
+    // Invalid: ActionList.Item with sx prop and ActionList imported from @primer/react
+    {
+      code: `import { ActionList } from '@primer/react'
+             const Component = () => <ActionList.Item sx={{ color: 'red' }}>Content</ActionList.Item>`,
+      output: `import { ActionList } from '@primer/styled-react'
+             const Component = () => <ActionList.Item sx={{ color: 'red' }}>Content</ActionList.Item>`,
+      errors: [
+        {
+          messageId: 'useStyledReactImport',
+          data: {componentName: 'ActionList'},
+        },
+      ],
+    },
+
+    // Invalid: FormControl used both with and without sx prop - should move to styled-react
+    {
+      code: `import { FormControl } from '@primer/react'
+             const Component = () => (
+               <div>
+                 <FormControl></FormControl>
+                 <FormControl sx={{ color: 'red' }}>
+                   <FormControl.Label visuallyHidden>Label</FormControl.Label>
+                 </FormControl>
+               </div>
+             )`,
+      output: `import { FormControl } from '@primer/styled-react'
+             const Component = () => (
+               <div>
+                 <FormControl></FormControl>
+                 <FormControl sx={{ color: 'red' }}>
+                   <FormControl.Label visuallyHidden>Label</FormControl.Label>
+                 </FormControl>
+               </div>
+             )`,
+      errors: [
+        {
+          messageId: 'useStyledReactImport',
+          data: {componentName: 'FormControl'},
+        },
+      ],
+    },
+
     // Invalid: Button with sx prop imported from @primer/react
     {
       code: `import { Button } from '@primer/react'
@@ -70,6 +112,41 @@ ruleTester.run('use-styled-react-import', rule, {
       ],
     },
 
+    // Invalid: ActionList used without sx, ActionList.Item used with sx - should move ActionList to styled-react
+    {
+      code: `import { ActionList, ActionMenu } from '@primer/react'
+             const Component = () => (
+               <ActionMenu>
+                 <ActionMenu.Overlay>
+                   <ActionList>
+                     <ActionList.Item sx={{ paddingLeft: 'calc(1 * var(--base-size-12))' }}>
+                       Item
+                     </ActionList.Item>
+                   </ActionList>
+                 </ActionMenu.Overlay>
+               </ActionMenu>
+             )`,
+      output: `import { ActionMenu } from '@primer/react'
+import { ActionList } from '@primer/styled-react'
+             const Component = () => (
+               <ActionMenu>
+                 <ActionMenu.Overlay>
+                   <ActionList>
+                     <ActionList.Item sx={{ paddingLeft: 'calc(1 * var(--base-size-12))' }}>
+                       Item
+                     </ActionList.Item>
+                   </ActionList>
+                 </ActionMenu.Overlay>
+               </ActionMenu>
+             )`,
+      errors: [
+        {
+          messageId: 'useStyledReactImport',
+          data: {componentName: 'ActionList'},
+        },
+      ],
+    },
+
     // Invalid: Multiple components, one with sx prop
     {
       code: `import { Button, Box, Avatar } from '@primer/react'
@@ -138,7 +215,7 @@ import { Button } from '@primer/styled-react'
       ],
     },
 
-    // Invalid: <Link /> and <StyledButton /> imported from styled-react but used without sx prop
+    // Invalid: <Link /> and <Button /> imported from styled-react but used without sx prop
     {
       code: `import { Button } from '@primer/react'
 import { Button as StyledButton, Link } from '@primer/styled-react'
@@ -155,7 +232,7 @@ import { Button as StyledButton, Link } from '@primer/styled-react'
                <div>
                  <Link />
                  <Button>Regular button</Button>
-                 <Button>Styled button</Button>
+                 <StyledButton>Styled button</StyledButton>
                </div>
              )`,
       errors: [
@@ -167,10 +244,6 @@ import { Button as StyledButton, Link } from '@primer/styled-react'
           messageId: 'usePrimerReactImport',
           data: {componentName: 'Link'},
         },
-        {
-          messageId: 'usePrimerReactImport',
-          data: {componentName: 'Button'},
-        },
       ],
     },
 
@@ -213,7 +286,7 @@ import { Button } from '@primer/react'
       ],
     },
 
-    // Invalid: Button used both with and without sx prop - should use alias
+    // Invalid: Button and Link used with sx prop - should move both to styled-react
     {
       code: `import { Button, Link } from '@primer/react'
              const Component = () => (
@@ -223,28 +296,23 @@ import { Button } from '@primer/react'
                  <Button sx={{ color: 'red' }}>Styled button</Button>
                </div>
              )`,
-      output: `import { Button } from '@primer/react'
-import { Button as StyledButton, Link } from '@primer/styled-react'
+      output: `import { Link, Button } from '@primer/styled-react'
              const Component = () => (
                <div>
                  <Link sx={{ color: 'red' }} />
                  <Button>Regular button</Button>
-                 <StyledButton sx={{ color: 'red' }}>Styled button</StyledButton>
+                 <Button sx={{ color: 'red' }}>Styled button</Button>
                </div>
              )`,
       errors: [
         {
-          messageId: 'useStyledReactImportWithAlias',
-          data: {componentName: 'Button', aliasName: 'StyledButton'},
+          messageId: 'useStyledReactImport',
+          data: {componentName: 'Button'},
         },
         {
           messageId: 'useStyledReactImport',
           data: {componentName: 'Link'},
         },
-        {
-          messageId: 'useAliasedComponent',
-          data: {componentName: 'Button', aliasName: 'StyledButton'},
-        },
       ],
     },
   ],

package/src/rules/use-styled-react-import.js

@@ -68,9 +68,6 @@ module.exports = {
     ],
     messages: {
       useStyledReactImport: 'Import {{ componentName }} from "@primer/styled-react" when using with sx prop',
-      useStyledReactImportWithAlias:
-        'Import {{ componentName }} as {{ aliasName }} from "@primer/styled-react" when using with sx prop (conflicts with non-sx usage)',
-      useAliasedComponent: 'Use {{ aliasName }} instead of {{ componentName }} when using sx prop',
       moveToStyledReact: 'Move {{ importName }} import to "@primer/styled-react"',
       usePrimerReactImport: 'Import {{ componentName }} from "@primer/react" when not using sx prop',
     },
@@ -86,9 +83,6 @@ module.exports = {
     const allUsedComponents = new Set() // Track all used components
     const primerReactImports = new Map() // Map of component name to import node
     const styledReactImports = new Map() // Map of components imported from styled-react to import node
-    const aliasMapping = new Map() // Map local name to original component name for aliased imports
-    const jsxElementsWithSx = [] // Track JSX elements that use sx prop
-    const jsxElementsWithoutSx = [] // Track JSX elements that don't use sx prop
 
     return {
       ImportDeclaration(node) {
@@ -113,13 +107,7 @@ module.exports = {
           for (const specifier of node.specifiers) {
             if (specifier.type === 'ImportSpecifier') {
               const importedName = specifier.imported.name
-              const localName = specifier.local.name
               styledReactImports.set(importedName, {node, specifier})
-
-              // Track alias mapping for styled-react imports
-              if (localName !== importedName) {
-                aliasMapping.set(localName, importedName)
-              }
             }
           }
         }
@@ -129,12 +117,12 @@ module.exports = {
         const openingElement = node.openingElement
         const componentName = getJSXOpeningElementName(openingElement)
 
-        // Check if this is an aliased component from styled-react
-        const originalComponentName = aliasMapping.get(componentName) || componentName
+        // For compound components like "ActionList.Item", we need to check the parent component
+        const parentComponentName = componentName.includes('.') ? componentName.split('.')[0] : componentName
 
         // Track all used components that are in our styled components list
-        if (styledComponents.has(originalComponentName)) {
-          allUsedComponents.add(originalComponentName)
+        if (styledComponents.has(parentComponentName)) {
+          allUsedComponents.add(parentComponentName)
 
           // Check if this component has an sx prop
           const hasSxProp = openingElement.attributes.some(
@@ -142,20 +130,9 @@ module.exports = {
           )
 
           if (hasSxProp) {
-            componentsWithSx.add(originalComponentName)
-            jsxElementsWithSx.push({node, componentName: originalComponentName, openingElement})
+            componentsWithSx.add(parentComponentName)
           } else {
-            componentsWithoutSx.add(originalComponentName)
-
-            // If this is an aliased component without sx, we need to track it for renaming
-            if (aliasMapping.has(componentName)) {
-              jsxElementsWithoutSx.push({
-                node,
-                localName: componentName,
-                originalName: originalComponentName,
-                openingElement,
-              })
-            }
+            componentsWithoutSx.add(parentComponentName)
           }
         }
       },
@@ -168,23 +145,16 @@ module.exports = {
         for (const componentName of componentsWithSx) {
           const importInfo = primerReactImports.get(componentName)
           if (importInfo && !styledReactImports.has(componentName)) {
-            const hasConflict = componentsWithoutSx.has(componentName)
             const {node: importNode} = importInfo
 
             if (!importNodeChanges.has(importNode)) {
               importNodeChanges.set(importNode, {
                 toMove: [],
-                toAlias: [],
                 originalSpecifiers: [...importNode.specifiers],
               })
             }
 
-            const changes = importNodeChanges.get(importNode)
-            if (hasConflict) {
-              changes.toAlias.push(componentName)
-            } else {
-              changes.toMove.push(componentName)
-            }
+            importNodeChanges.get(importNode).toMove.push(componentName)
           }
         }
 
@@ -192,15 +162,12 @@ module.exports = {
         for (const componentName of componentsWithSx) {
           const importInfo = primerReactImports.get(componentName)
           if (importInfo && !styledReactImports.has(componentName)) {
-            // Check if this component is also used without sx prop (conflict scenario)
-            const hasConflict = componentsWithoutSx.has(componentName)
-
             context.report({
               node: importInfo.specifier,
-              messageId: hasConflict ? 'useStyledReactImportWithAlias' : 'useStyledReactImport',
-              data: hasConflict ? {componentName, aliasName: `Styled${componentName}`} : {componentName},
+              messageId: 'useStyledReactImport',
+              data: {componentName},
               fix(fixer) {
-                const {node: importNode, specifier} = importInfo
+                const {node: importNode} = importInfo
                 const changes = importNodeChanges.get(importNode)
 
                 if (!changes) {
@@ -208,10 +175,7 @@ module.exports = {
                 }
 
                 // Only apply the fix once per import node (for the first component processed)
-                const isFirstComponent =
-                  changes.originalSpecifiers[0] === specifier ||
-                  (changes.toMove.length > 0 && changes.toMove[0] === componentName) ||
-                  (changes.toAlias.length > 0 && changes.toAlias[0] === componentName)
+                const isFirstComponent = changes.toMove[0] === componentName
 
                 if (!isFirstComponent) {
                   return null
@@ -223,27 +187,13 @@ module.exports = {
                 // Find specifiers that remain in original import
                 const remainingSpecifiers = changes.originalSpecifiers.filter(spec => {
                   const name = spec.imported.name
-                  // Keep components that are not being moved (only aliased components stay for non-sx usage)
                   return !componentsToMove.has(name)
                 })
 
-                // If no components remain, replace with new imports directly
+                // If no components remain, replace with new import directly
                 if (remainingSpecifiers.length === 0) {
-                  // Build the new imports to replace the original
-                  const newImports = []
-
-                  // Add imports for moved components
-                  for (const componentName of changes.toMove) {
-                    newImports.push(`import { ${componentName} } from '@primer/styled-react'`)
-                  }
-
-                  // Add aliased imports for conflicted components
-                  for (const componentName of changes.toAlias) {
-                    const aliasName = `Styled${componentName}`
-                    newImports.push(`import { ${componentName} as ${aliasName} } from '@primer/styled-react'`)
-                  }
-
-                  fixes.push(fixer.replaceText(importNode, newImports.join('\n')))
+                  const movedComponents = changes.toMove.join(', ')
+                  fixes.push(fixer.replaceText(importNode, `import { ${movedComponents} } from '@primer/styled-react'`))
                 } else {
                   // Otherwise, update the import to only include remaining components
                   const remainingNames = remainingSpecifiers.map(spec => spec.imported.name)
@@ -251,56 +201,11 @@ module.exports = {
                     fixer.replaceText(importNode, `import { ${remainingNames.join(', ')} } from '@primer/react'`),
                   )
 
-                  // Combine all styled-react imports into a single import statement
-                  const styledReactImports = []
-
-                  // Add aliased components first
-                  for (const componentName of changes.toAlias) {
-                    const aliasName = `Styled${componentName}`
-                    styledReactImports.push(`${componentName} as ${aliasName}`)
-                  }
-
-                  // Add moved components second
-                  for (const componentName of changes.toMove) {
-                    styledReactImports.push(componentName)
-                  }
-
-                  if (styledReactImports.length > 0) {
-                    fixes.push(
-                      fixer.insertTextAfter(
-                        importNode,
-                        `\nimport { ${styledReactImports.join(', ')} } from '@primer/styled-react'`,
-                      ),
-                    )
-                  }
-                }
-
-                return fixes
-              },
-            })
-          }
-        }
-
-        // Report on JSX elements that should use aliased components
-        for (const {node: jsxNode, componentName, openingElement} of jsxElementsWithSx) {
-          const hasConflict = componentsWithoutSx.has(componentName)
-          const isImportedFromPrimerReact = primerReactImports.has(componentName)
-
-          if (hasConflict && isImportedFromPrimerReact && !styledReactImports.has(componentName)) {
-            const aliasName = `Styled${componentName}`
-            context.report({
-              node: openingElement,
-              messageId: 'useAliasedComponent',
-              data: {componentName, aliasName},
-              fix(fixer) {
-                const fixes = []
-
-                // Replace the component name in the JSX opening tag
-                fixes.push(fixer.replaceText(openingElement.name, aliasName))
-
-                // Replace the component name in the JSX closing tag if it exists
-                if (jsxNode.closingElement) {
-                  fixes.push(fixer.replaceText(jsxNode.closingElement.name, aliasName))
+                  // Add new styled-react import
+                  const movedComponents = changes.toMove.join(', ')
+                  fixes.push(
+                    fixer.insertTextAfter(importNode, `\nimport { ${movedComponents} } from '@primer/styled-react'`),
+                  )
                 }
 
                 return fixes
@@ -430,30 +335,6 @@ module.exports = {
           }
         }
 
-        // Report and fix JSX elements that use aliased components without sx prop
-        for (const {node: jsxNode, originalName, openingElement} of jsxElementsWithoutSx) {
-          if (!componentsWithSx.has(originalName) && styledReactImports.has(originalName)) {
-            context.report({
-              node: openingElement,
-              messageId: 'usePrimerReactImport',
-              data: {componentName: originalName},
-              fix(fixer) {
-                const fixes = []
-
-                // Replace the aliased component name with the original component name in JSX opening tag
-                fixes.push(fixer.replaceText(openingElement.name, originalName))
-
-                // Replace the aliased component name in JSX closing tag if it exists
-                if (jsxNode.closingElement) {
-                  fixes.push(fixer.replaceText(jsxNode.closingElement.name, originalName))
-                }
-
-                return fixes
-              },
-            })
-          }
-        }
-
         // Also report for types and utilities that should always be from styled-react
         for (const [importName, importInfo] of primerReactImports) {
           if ((styledTypes.has(importName) || styledUtilities.has(importName)) && !styledReactImports.has(importName)) {