fix: move parentheses when sorting

rules/sort-union-types.ts

@@ -1,4 +1,5 @@
 import { createEslintRule } from '~/utils/create-eslint-rule'
+import { toSingleLine } from '~/utils/to-single-line'
 import { rangeToDiff } from '~/utils/range-to-diff'
 import { SortType, SortOrder } from '~/typings'
 import { sortNodes } from '~/utils/sort-nodes'
@@ -78,8 +79,8 @@ export default createEslintRule<Options, MESSAGE_ID>({
           context.report({
             messageId: 'unexpectedUnionTypesOrder',
             data: {
-              first: first.name,
-              second: second.name,
+              first: toSingleLine(first.name),
+              second: toSingleLine(second.name),
             },
             node: second.node,
             fix: fixer =>

test/sort-union-types.test.ts

@@ -216,6 +216,51 @@ describe(RULE_NAME, () => {
         ],
       })
     })
+
+    it(`${RULE_NAME}: sorts unions with parentheses`, () => {
+      ruleTester.run(RULE_NAME, rule, {
+        valid: [],
+        invalid: [
+          {
+            code: dedent`
+              type HeroAssociation = {
+                team:
+                  | Saitama
+                  | ((
+                      superstrike: () => void,
+                    ) => Hero[] | Saitama)
+                  | Hero[]
+              }
+            `,
+            output: dedent`
+              type HeroAssociation = {
+                team:
+                  | ((
+                      superstrike: () => void,
+                    ) => Hero[] | Saitama)
+                  | Hero[]
+                  | Saitama
+              }
+            `,
+            options: [
+              {
+                type: SortType.alphabetical,
+                order: SortOrder.asc,
+              },
+            ],
+            errors: [
+              {
+                messageId: 'unexpectedUnionTypesOrder',
+                data: {
+                  first: 'Saitama',
+                  second: '( superstrike: () => void, ) => Hero[] | Saitama',
+                },
+              },
+            ],
+          },
+        ],
+      })
+    })
   })
 
   describe(`${RULE_NAME}: sorting by natural order`, () => {
@@ -424,6 +469,51 @@ describe(RULE_NAME, () => {
         ],
       })
     })
+
+    it(`${RULE_NAME}: sorts unions with parentheses`, () => {
+      ruleTester.run(RULE_NAME, rule, {
+        valid: [],
+        invalid: [
+          {
+            code: dedent`
+              type HeroAssociation = {
+                team:
+                  | Saitama
+                  | ((
+                      superstrike: () => void,
+                    ) => Hero[] | Saitama)
+                  | Hero[]
+              }
+            `,
+            output: dedent`
+              type HeroAssociation = {
+                team:
+                  | ((
+                      superstrike: () => void,
+                    ) => Hero[] | Saitama)
+                  | Hero[]
+                  | Saitama
+              }
+            `,
+            options: [
+              {
+                type: SortType.natural,
+                order: SortOrder.asc,
+              },
+            ],
+            errors: [
+              {
+                messageId: 'unexpectedUnionTypesOrder',
+                data: {
+                  first: 'Saitama',
+                  second: '( superstrike: () => void, ) => Hero[] | Saitama',
+                },
+              },
+            ],
+          },
+        ],
+      })
+    })
   })
 
   describe(`${RULE_NAME}: sorting by line length`, () => {
@@ -615,5 +705,57 @@ describe(RULE_NAME, () => {
         ],
       })
     })
+
+    it(`${RULE_NAME}: sorts unions with parentheses`, () => {
+      ruleTester.run(RULE_NAME, rule, {
+        valid: [],
+        invalid: [
+          {
+            code: dedent`
+              type HeroAssociation = {
+                team:
+                  | Saitama
+                  | ((
+                      superstrike: () => void,
+                    ) => Hero[] | Saitama)
+                  | Hero[]
+              }
+            `,
+            output: dedent`
+              type HeroAssociation = {
+                team:
+                  | ((
+                      superstrike: () => void,
+                    ) => Hero[] | Saitama)
+                  | Saitama
+                  | Hero[]
+              }
+            `,
+            options: [
+              {
+                type: SortType['line-length'],
+                order: SortOrder.desc,
+              },
+            ],
+            errors: [
+              {
+                messageId: 'unexpectedUnionTypesOrder',
+                data: {
+                  first: 'Saitama',
+                  second: '( superstrike: () => void, ) => Hero[] | Saitama',
+                },
+              },
+              {
+                messageId: 'unexpectedUnionTypesOrder',
+                data: {
+                  first: 'Hero[]',
+                  second: 'Saitama',
+                },
+              },
+            ],
+          },
+        ],
+      })
+    })
   })
 })

utils/get-node-range.ts

@@ -1,12 +1,37 @@
 import type { TSESLint } from '@typescript-eslint/utils'
 import type { TSESTree } from '@typescript-eslint/types'
 
+import { ASTUtils } from '@typescript-eslint/utils'
+
 import { getComment } from '~/utils/get-comment'
 
 export let getNodeRange = (
   node: TSESTree.Node,
   sourceCode: TSESLint.SourceCode,
 ): TSESTree.Range => {
+  let start = node.range.at(0)!
+  let end = node.range.at(1)!
+
+  if (ASTUtils.isParenthesized(node, sourceCode)) {
+    let bodyOpeningParen = sourceCode.getTokenBefore(
+      node,
+      ASTUtils.isOpeningParenToken,
+    )!
+
+    let bodyClosingParen = sourceCode.getTokenAfter(
+      node,
+      ASTUtils.isClosingParenToken,
+    )!
+
+    start = bodyOpeningParen.range.at(0)!
+    end = bodyClosingParen.range.at(1)!
+  }
+
   let comment = getComment(node, sourceCode)
-  return [comment?.range.at(0) ?? node.range.at(0)!, node.range.at(1)!]
+
+  if (comment) {
+    start = comment.range.at(0)!
+  }
+
+  return [start, end]
 }

utils/to-single-line.ts

@@ -0,0 +1,2 @@
+export let toSingleLine = (string: string): string =>
+  string.replaceAll(/\s\s+/g, ' ').trim()