feat(sort-enums): add partition-by-comment option

docs/rules/sort-enums.md

@@ -71,6 +71,7 @@ interface Options {
   type?: 'alphabetical' | 'natural' | 'line-length'
   order?: 'asc' | 'desc'
   'ignore-case'?: boolean
+  'partition-by-comment'?: string[] | string | boolean
 }
 ```
 
@@ -95,6 +96,14 @@ interface Options {
 
 Only affects alphabetical and natural sorting. When `true` the rule ignores the case-sensitivity of the order.
 
+### partition-by-comment
+
+<sub>(default: `false`)</sub>
+
+You can set comments that would separate the members of enums into logical parts. If set to `true`, all enum member comments will be treated as delimiters.
+
+The [minimatch](https://github.com/isaacs/minimatch) library is used for pattern matching.
+
 ## ⚙️ Usage
 
 ::: code-group

rules/sort-enums.ts

@@ -1,6 +1,8 @@
-import type { SortingNode } from '../typings'
+import type { PartitionComment, SortingNode } from '../typings'
 
+import { isPartitionComment } from '../utils/is-partition-comment'
 import { createEslintRule } from '../utils/create-eslint-rule'
+import { getCommentBefore } from '../utils/get-comment-before'
 import { toSingleLine } from '../utils/to-single-line'
 import { rangeToDiff } from '../utils/range-to-diff'
 import { isPositive } from '../utils/is-positive'
@@ -15,6 +17,7 @@ type MESSAGE_ID = 'unexpectedEnumsOrder'
 
 type Options = [
   Partial<{
+    'partition-by-comment': PartitionComment
     'ignore-case': boolean
     order: SortOrder
     type: SortType
@@ -35,6 +38,10 @@ export default createEslintRule<Options, MESSAGE_ID>({
       {
         type: 'object',
         properties: {
+          'partition-by-comment': {
+            default: false,
+            type: ['boolean', 'string', 'array'],
+          },
           type: {
             enum: [
               SortType.alphabetical,
@@ -77,36 +84,61 @@ export default createEslintRule<Options, MESSAGE_ID>({
           type: SortType.alphabetical,
           order: SortOrder.asc,
           'ignore-case': false,
+          'partition-by-comment': false,
         })
 
-        let nodes: SortingNode[] = node.members.map(member => ({
-          name:
-            member.id.type === 'Literal'
-              ? `${member.id.value}`
-              : `${context.sourceCode.text.slice(...member.id.range)}`,
-          size: rangeToDiff(member.range),
-          node: member,
-        }))
+        let partitionComment = options['partition-by-comment']
 
-        pairwise(nodes, (left, right) => {
-          if (isPositive(compare(left, right, options))) {
-            context.report({
-              messageId: 'unexpectedEnumsOrder',
-              data: {
-                left: toSingleLine(left.name),
-                right: toSingleLine(right.name),
-              },
-              node: right.node,
-              fix: fixer =>
-                makeFixes(
-                  fixer,
-                  nodes,
-                  sortNodes(nodes, options),
-                  context.sourceCode,
-                ),
-            })
-          }
-        })
+        let formattedMembers: SortingNode[][] = node.members.reduce(
+          (accumulator: SortingNode[][], member) => {
+            let comment = getCommentBefore(member, context.sourceCode)
+
+            if (
+              partitionComment &&
+              comment &&
+              isPartitionComment(partitionComment, comment.value)
+            ) {
+              accumulator.push([])
+            }
+
+            let name =
+              member.id.type === 'Literal'
+                ? `${member.id.value}`
+                : `${context.sourceCode.text.slice(...member.id.range)}`
+
+            let sortingNode = {
+              name,
+              node: member,
+              size: rangeToDiff(member.range),
+            }
+            accumulator.at(-1)!.push(sortingNode)
+            return accumulator
+          },
+          [[]],
+        )
+
+        for (let nodes of formattedMembers) {
+          pairwise(nodes, (left, right) => {
+            if (isPositive(compare(left, right, options))) {
+              context.report({
+                messageId: 'unexpectedEnumsOrder',
+                data: {
+                  left: toSingleLine(left.name),
+                  right: toSingleLine(right.name),
+                },
+                node: right.node,
+                fix: fixer =>
+                  makeFixes(
+                    fixer,
+                    nodes,
+                    sortNodes(nodes, options),
+                    context.sourceCode,
+                    { partitionComment },
+                  ),
+              })
+            }
+          })
+        }
       }
     },
   }),