eslint-plugin-perfectionist 3.6.0 → 3.7.0

package/dist/rules/sort-astro-attributes.mjs

@@ -1,17 +1,15 @@
 import path from 'node:path'
 import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.mjs'
+import { sortNodesByGroups } from '../utils/sort-nodes-by-groups.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
 import { getGroupNumber } from '../utils/get-group-number.mjs'
 import { getSourceCode } from '../utils/get-source-code.mjs'
 import { rangeToDiff } from '../utils/range-to-diff.mjs'
 import { getSettings } from '../utils/get-settings.mjs'
-import { isPositive } from '../utils/is-positive.mjs'
 import { useGroups } from '../utils/use-groups.mjs'
 import { makeFixes } from '../utils/make-fixes.mjs'
-import { sortNodes } from '../utils/sort-nodes.mjs'
 import { pairwise } from '../utils/pairwise.mjs'
 import { complete } from '../utils/complete.mjs'
-import { compare } from '../utils/compare.mjs'
 const sortAstroAttributes = createEslintRule({
   name: 'sort-astro-attributes',
   meta: {
@@ -152,14 +150,13 @@ const sortAstroAttributes = createEslintRule({
             [[]],
           )
           for (let nodes of parts) {
+            let sortedNodes = sortNodesByGroups(nodes, options)
             pairwise(nodes, (left, right) => {
-              let leftNum = getGroupNumber(options.groups, left)
-              let rightNum = getGroupNumber(options.groups, right)
-              if (
-                leftNum > rightNum ||
-                (leftNum === rightNum &&
-                  isPositive(compare(left, right, options)))
-              ) {
+              let indexOfLeft = sortedNodes.indexOf(left)
+              let indexOfRight = sortedNodes.indexOf(right)
+              if (indexOfLeft > indexOfRight) {
+                let leftNum = getGroupNumber(options.groups, left)
+                let rightNum = getGroupNumber(options.groups, right)
                 context.report({
                   messageId:
                     leftNum !== rightNum
@@ -172,27 +169,8 @@ const sortAstroAttributes = createEslintRule({
                     rightGroup: right.group,
                   },
                   node: right.node,
-                  fix: fixer => {
-                    let grouped = {}
-                    for (let currentNode of nodes) {
-                      let groupNum = getGroupNumber(options.groups, currentNode)
-                      if (!(groupNum in grouped)) {
-                        grouped[groupNum] = [currentNode]
-                      } else {
-                        grouped[groupNum] = sortNodes(
-                          [...grouped[groupNum], currentNode],
-                          options,
-                        )
-                      }
-                    }
-                    let sortedNodes = []
-                    for (let group of Object.keys(grouped).sort(
-                      (a, b) => Number(a) - Number(b),
-                    )) {
-                      sortedNodes.push(...sortNodes(grouped[group], options))
-                    }
-                    return makeFixes(fixer, nodes, sortedNodes, sourceCode)
-                  },
+                  fix: fixer =>
+                    makeFixes(fixer, nodes, sortedNodes, sourceCode),
                 })
               }
             })

package/dist/rules/sort-classes.js

@@ -45,7 +45,7 @@ const sortClasses = createEslintRule.createEslintRule({
           },
           partitionByComment: {
             description:
-              'Allows to use comments to separate the nodes into logical groups.',
+              'Allows to use comments to separate the class members into logical groups.',
             anyOf: [
               {
                 type: 'array',
@@ -145,6 +145,8 @@ const sortClasses = createEslintRule.createEslintRule({
       unexpectedClassesGroupOrder:
         'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedClassesOrder: 'Expected "{{right}}" to come before "{{left}}".',
+      unexpectedClassesDependencyOrder:
+        'Expected dependency "{{right}}" to come before "{{nodeDependentOnRight}}".',
     },
   },
   defaultOptions: [
@@ -532,10 +534,11 @@ const sortClasses = createEslintRule.createEslintRule({
           },
           [[]],
         )
-        for (let nodes of formattedNodes) {
+        let sortedNodes = []
+        for (let nodes2 of formattedNodes) {
           let nodesByNonIgnoredGroupNumber = {}
           let ignoredNodeIndices = []
-          for (let [index, sortingNode] of nodes.entries()) {
+          for (let [index, sortingNode] of nodes2.entries()) {
             let groupNum = getGroupNumber.getGroupNumber(
               options.groups,
               sortingNode,
@@ -548,7 +551,6 @@ const sortClasses = createEslintRule.createEslintRule({
               nodesByNonIgnoredGroupNumber[groupNum] ?? []
             nodesByNonIgnoredGroupNumber[groupNum].push(sortingNode)
           }
-          let sortedNodes = []
           for (let groupNumber of Object.keys(
             nodesByNonIgnoredGroupNumber,
           ).sort((a, b) => Number(a) - Number(b))) {
@@ -570,39 +572,58 @@ const sortClasses = createEslintRule.createEslintRule({
             }
           }
           for (let ignoredIndex of ignoredNodeIndices) {
-            sortedNodes.splice(ignoredIndex, 0, nodes[ignoredIndex])
+            sortedNodes.splice(ignoredIndex, 0, nodes2[ignoredIndex])
           }
-          sortedNodes =
-            sortNodesByDependencies.sortNodesByDependencies(sortedNodes)
-          pairwise.pairwise(nodes, (left, right) => {
-            let leftNum = getGroupNumber.getGroupNumber(options.groups, left)
-            let rightNum = getGroupNumber.getGroupNumber(options.groups, right)
-            let isLeftOrRightIgnored =
-              leftNum === options.groups.length ||
-              rightNum === options.groups.length
-            let indexOfLeft = sortedNodes.indexOf(left)
-            let indexOfRight = sortedNodes.indexOf(right)
-            if (!isLeftOrRightIgnored && indexOfLeft > indexOfRight) {
-              context.report({
-                messageId:
-                  leftNum !== rightNum
-                    ? 'unexpectedClassesGroupOrder'
-                    : 'unexpectedClassesOrder',
-                data: {
-                  left: toSingleLine.toSingleLine(left.name),
-                  leftGroup: left.group,
-                  right: toSingleLine.toSingleLine(right.name),
-                  rightGroup: right.group,
-                },
-                node: right.node,
-                fix: fixer =>
-                  makeFixes.makeFixes(fixer, nodes, sortedNodes, sourceCode, {
-                    partitionComment: options.partitionByComment,
-                  }),
-              })
-            }
-          })
         }
+        sortedNodes =
+          sortNodesByDependencies.sortNodesByDependencies(sortedNodes)
+        let nodes = formattedNodes.flat()
+        pairwise.pairwise(nodes, (left, right) => {
+          let leftNum = getGroupNumber.getGroupNumber(options.groups, left)
+          let rightNum = getGroupNumber.getGroupNumber(options.groups, right)
+          let isLeftOrRightIgnored =
+            leftNum === options.groups.length ||
+            rightNum === options.groups.length
+          let indexOfLeft = sortedNodes.indexOf(left)
+          let indexOfRight = sortedNodes.indexOf(right)
+          let firstUnorderedNodeDependentOnRight =
+            sortNodesByDependencies.getFirstUnorderedNodeDependentOn(
+              right,
+              nodes,
+            )
+          if (
+            firstUnorderedNodeDependentOnRight ||
+            (!isLeftOrRightIgnored && indexOfLeft > indexOfRight)
+          ) {
+            let messageId
+            if (firstUnorderedNodeDependentOnRight) {
+              messageId = 'unexpectedClassesDependencyOrder'
+            } else {
+              messageId =
+                leftNum !== rightNum
+                  ? 'unexpectedClassesGroupOrder'
+                  : 'unexpectedClassesOrder'
+            }
+            context.report({
+              messageId,
+              data: {
+                left: toSingleLine.toSingleLine(left.name),
+                leftGroup: left.group,
+                right: toSingleLine.toSingleLine(right.name),
+                rightGroup: right.group,
+                nodeDependentOnRight:
+                  firstUnorderedNodeDependentOnRight == null
+                    ? void 0
+                    : firstUnorderedNodeDependentOnRight.name,
+              },
+              node: right.node,
+              fix: fixer =>
+                makeFixes.makeFixes(fixer, nodes, sortedNodes, sourceCode, {
+                  partitionComment: options.partitionByComment,
+                }),
+            })
+          }
+        })
       }
     },
   }),

package/dist/rules/sort-classes.mjs

@@ -9,7 +9,10 @@ import {
   customGroupSortJsonSchema,
   singleCustomGroupJsonSchema,
 } from './sort-classes.types.mjs'
-import { sortNodesByDependencies } from '../utils/sort-nodes-by-dependencies.mjs'
+import {
+  sortNodesByDependencies,
+  getFirstUnorderedNodeDependentOn,
+} from '../utils/sort-nodes-by-dependencies.mjs'
 import { hasPartitionComment } from '../utils/is-partition-comment.mjs'
 import { getCommentsBefore } from '../utils/get-comments-before.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
@@ -53,7 +56,7 @@ const sortClasses = createEslintRule({
           },
           partitionByComment: {
             description:
-              'Allows to use comments to separate the nodes into logical groups.',
+              'Allows to use comments to separate the class members into logical groups.',
             anyOf: [
               {
                 type: 'array',
@@ -153,6 +156,8 @@ const sortClasses = createEslintRule({
       unexpectedClassesGroupOrder:
         'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedClassesOrder: 'Expected "{{right}}" to come before "{{left}}".',
+      unexpectedClassesDependencyOrder:
+        'Expected dependency "{{right}}" to come before "{{nodeDependentOnRight}}".',
     },
   },
   defaultOptions: [
@@ -534,10 +539,11 @@ const sortClasses = createEslintRule({
           },
           [[]],
         )
-        for (let nodes of formattedNodes) {
+        let sortedNodes = []
+        for (let nodes2 of formattedNodes) {
           let nodesByNonIgnoredGroupNumber = {}
           let ignoredNodeIndices = []
-          for (let [index, sortingNode] of nodes.entries()) {
+          for (let [index, sortingNode] of nodes2.entries()) {
             let groupNum = getGroupNumber(options.groups, sortingNode)
             if (groupNum === options.groups.length) {
               ignoredNodeIndices.push(index)
@@ -547,7 +553,6 @@ const sortClasses = createEslintRule({
               nodesByNonIgnoredGroupNumber[groupNum] ?? []
             nodesByNonIgnoredGroupNumber[groupNum].push(sortingNode)
           }
-          let sortedNodes = []
           for (let groupNumber of Object.keys(
             nodesByNonIgnoredGroupNumber,
           ).sort((a, b) => Number(a) - Number(b))) {
@@ -566,38 +571,54 @@ const sortClasses = createEslintRule({
             }
           }
           for (let ignoredIndex of ignoredNodeIndices) {
-            sortedNodes.splice(ignoredIndex, 0, nodes[ignoredIndex])
+            sortedNodes.splice(ignoredIndex, 0, nodes2[ignoredIndex])
           }
-          sortedNodes = sortNodesByDependencies(sortedNodes)
-          pairwise(nodes, (left, right) => {
-            let leftNum = getGroupNumber(options.groups, left)
-            let rightNum = getGroupNumber(options.groups, right)
-            let isLeftOrRightIgnored =
-              leftNum === options.groups.length ||
-              rightNum === options.groups.length
-            let indexOfLeft = sortedNodes.indexOf(left)
-            let indexOfRight = sortedNodes.indexOf(right)
-            if (!isLeftOrRightIgnored && indexOfLeft > indexOfRight) {
-              context.report({
-                messageId:
-                  leftNum !== rightNum
-                    ? 'unexpectedClassesGroupOrder'
-                    : 'unexpectedClassesOrder',
-                data: {
-                  left: toSingleLine(left.name),
-                  leftGroup: left.group,
-                  right: toSingleLine(right.name),
-                  rightGroup: right.group,
-                },
-                node: right.node,
-                fix: fixer =>
-                  makeFixes(fixer, nodes, sortedNodes, sourceCode, {
-                    partitionComment: options.partitionByComment,
-                  }),
-              })
-            }
-          })
         }
+        sortedNodes = sortNodesByDependencies(sortedNodes)
+        let nodes = formattedNodes.flat()
+        pairwise(nodes, (left, right) => {
+          let leftNum = getGroupNumber(options.groups, left)
+          let rightNum = getGroupNumber(options.groups, right)
+          let isLeftOrRightIgnored =
+            leftNum === options.groups.length ||
+            rightNum === options.groups.length
+          let indexOfLeft = sortedNodes.indexOf(left)
+          let indexOfRight = sortedNodes.indexOf(right)
+          let firstUnorderedNodeDependentOnRight =
+            getFirstUnorderedNodeDependentOn(right, nodes)
+          if (
+            firstUnorderedNodeDependentOnRight ||
+            (!isLeftOrRightIgnored && indexOfLeft > indexOfRight)
+          ) {
+            let messageId
+            if (firstUnorderedNodeDependentOnRight) {
+              messageId = 'unexpectedClassesDependencyOrder'
+            } else {
+              messageId =
+                leftNum !== rightNum
+                  ? 'unexpectedClassesGroupOrder'
+                  : 'unexpectedClassesOrder'
+            }
+            context.report({
+              messageId,
+              data: {
+                left: toSingleLine(left.name),
+                leftGroup: left.group,
+                right: toSingleLine(right.name),
+                rightGroup: right.group,
+                nodeDependentOnRight:
+                  firstUnorderedNodeDependentOnRight == null
+                    ? void 0
+                    : firstUnorderedNodeDependentOnRight.name,
+              },
+              node: right.node,
+              fix: fixer =>
+                makeFixes(fixer, nodes, sortedNodes, sourceCode, {
+                  partitionComment: options.partitionByComment,
+                }),
+            })
+          }
+        })
       }
     },
   }),

package/dist/rules/sort-enums.js

@@ -3,6 +3,7 @@ const sortNodesByDependencies = require('../utils/sort-nodes-by-dependencies.js'
 const isPartitionComment = require('../utils/is-partition-comment.js')
 const getCommentsBefore = require('../utils/get-comments-before.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
+const getLinesBetween = require('../utils/get-lines-between.js')
 const getSourceCode = require('../utils/get-source-code.js')
 const toSingleLine = require('../utils/to-single-line.js')
 const rangeToDiff = require('../utils/range-to-diff.js')
@@ -50,7 +51,7 @@ const sortEnums = createEslintRule.createEslintRule({
           },
           partitionByComment: {
             description:
-              'Allows you to use comments to separate the class members into logical groups.',
+              'Allows you to use comments to separate the members of enums into logical groups.',
             anyOf: [
               {
                 type: 'array',
@@ -66,12 +67,19 @@ const sortEnums = createEslintRule.createEslintRule({
               },
             ],
           },
+          partitionByNewLine: {
+            description:
+              'Allows to use spaces to separate the nodes into logical groups.',
+            type: 'boolean',
+          },
         },
         additionalProperties: false,
       },
     ],
     messages: {
       unexpectedEnumsOrder: 'Expected "{{right}}" to come before "{{left}}".',
+      unexpectedEnumsDependencyOrder:
+        'Expected dependency "{{right}}" to come before "{{nodeDependentOnRight}}".',
     },
   },
   defaultOptions: [
@@ -81,6 +89,7 @@ const sortEnums = createEslintRule.createEslintRule({
       ignoreCase: true,
       sortByValue: false,
       partitionByComment: false,
+      partitionByNewLine: false,
       forceNumericSort: false,
     },
   ],
@@ -104,6 +113,7 @@ const sortEnums = createEslintRule.createEslintRule({
         let settings = getSettings.getSettings(context.settings)
         let options = complete.complete(context.options.at(0), settings, {
           partitionByComment: false,
+          partitionByNewLine: false,
           type: 'alphabetical',
           ignoreCase: true,
           order: 'asc',
@@ -140,20 +150,7 @@ const sortEnums = createEslintRule.createEslintRule({
         }
         let formattedMembers = members.reduce(
           (accumulator, member) => {
-            let comments = getCommentsBefore.getCommentsBefore(
-              member,
-              sourceCode,
-            )
-            if (
-              partitionComment &&
-              isPartitionComment.hasPartitionComment(partitionComment, comments)
-            ) {
-              accumulator.push([])
-            }
-            let name =
-              member.id.type === 'Literal'
-                ? `${member.id.value}`
-                : `${sourceCode.text.slice(...member.id.range)}`
+            var _a
             let dependencies = []
             if (member.initializer) {
               dependencies = extractDependencies(
@@ -161,11 +158,32 @@ const sortEnums = createEslintRule.createEslintRule({
                 node.id.name,
               )
             }
+            let lastSortingNode =
+              (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1)
             let sortingNode = {
               size: rangeToDiff.rangeToDiff(member.range),
               node: member,
               dependencies,
-              name,
+              name:
+                member.id.type === 'Literal'
+                  ? `${member.id.value}`
+                  : `${sourceCode.text.slice(...member.id.range)}`,
+            }
+            if (
+              (partitionComment &&
+                isPartitionComment.hasPartitionComment(
+                  partitionComment,
+                  getCommentsBefore.getCommentsBefore(member, sourceCode),
+                )) ||
+              (options.partitionByNewLine &&
+                lastSortingNode &&
+                getLinesBetween.getLinesBetween(
+                  sourceCode,
+                  lastSortingNode,
+                  sortingNode,
+                ))
+            ) {
+              accumulator.push([])
             }
             accumulator.at(-1).push(sortingNode)
             return accumulator
@@ -208,29 +226,41 @@ const sortEnums = createEslintRule.createEslintRule({
                 }
               : void 0,
         }
-        for (let nodes of formattedMembers) {
-          let sortedNodes = sortNodesByDependencies.sortNodesByDependencies(
-            sortNodes.sortNodes(nodes, compareOptions),
-          )
-          pairwise.pairwise(nodes, (left, right) => {
-            let indexOfLeft = sortedNodes.indexOf(left)
-            let indexOfRight = sortedNodes.indexOf(right)
-            if (indexOfLeft > indexOfRight) {
-              context.report({
-                messageId: 'unexpectedEnumsOrder',
-                data: {
-                  left: toSingleLine.toSingleLine(left.name),
-                  right: toSingleLine.toSingleLine(right.name),
-                },
-                node: right.node,
-                fix: fixer =>
-                  makeFixes.makeFixes(fixer, nodes, sortedNodes, sourceCode, {
-                    partitionComment,
-                  }),
-              })
-            }
-          })
-        }
+        let sortedNodes = sortNodesByDependencies.sortNodesByDependencies(
+          formattedMembers
+            .map(nodes2 => sortNodes.sortNodes(nodes2, compareOptions))
+            .flat(),
+        )
+        let nodes = formattedMembers.flat()
+        pairwise.pairwise(nodes, (left, right) => {
+          let indexOfLeft = sortedNodes.indexOf(left)
+          let indexOfRight = sortedNodes.indexOf(right)
+          if (indexOfLeft > indexOfRight) {
+            let firstUnorderedNodeDependentOnRight =
+              sortNodesByDependencies.getFirstUnorderedNodeDependentOn(
+                right,
+                nodes,
+              )
+            context.report({
+              messageId: firstUnorderedNodeDependentOnRight
+                ? 'unexpectedEnumsDependencyOrder'
+                : 'unexpectedEnumsOrder',
+              data: {
+                left: toSingleLine.toSingleLine(left.name),
+                right: toSingleLine.toSingleLine(right.name),
+                nodeDependentOnRight:
+                  firstUnorderedNodeDependentOnRight == null
+                    ? void 0
+                    : firstUnorderedNodeDependentOnRight.name,
+              },
+              node: right.node,
+              fix: fixer =>
+                makeFixes.makeFixes(fixer, nodes, sortedNodes, sourceCode, {
+                  partitionComment,
+                }),
+            })
+          }
+        })
       }
     },
   }),

package/dist/rules/sort-enums.mjs

@@ -1,7 +1,11 @@
-import { sortNodesByDependencies } from '../utils/sort-nodes-by-dependencies.mjs'
+import {
+  sortNodesByDependencies,
+  getFirstUnorderedNodeDependentOn,
+} from '../utils/sort-nodes-by-dependencies.mjs'
 import { hasPartitionComment } from '../utils/is-partition-comment.mjs'
 import { getCommentsBefore } from '../utils/get-comments-before.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
+import { getLinesBetween } from '../utils/get-lines-between.mjs'
 import { getSourceCode } from '../utils/get-source-code.mjs'
 import { toSingleLine } from '../utils/to-single-line.mjs'
 import { rangeToDiff } from '../utils/range-to-diff.mjs'
@@ -49,7 +53,7 @@ const sortEnums = createEslintRule({
           },
           partitionByComment: {
             description:
-              'Allows you to use comments to separate the class members into logical groups.',
+              'Allows you to use comments to separate the members of enums into logical groups.',
             anyOf: [
               {
                 type: 'array',
@@ -65,12 +69,19 @@ const sortEnums = createEslintRule({
               },
             ],
           },
+          partitionByNewLine: {
+            description:
+              'Allows to use spaces to separate the nodes into logical groups.',
+            type: 'boolean',
+          },
         },
         additionalProperties: false,
       },
     ],
     messages: {
       unexpectedEnumsOrder: 'Expected "{{right}}" to come before "{{left}}".',
+      unexpectedEnumsDependencyOrder:
+        'Expected dependency "{{right}}" to come before "{{nodeDependentOnRight}}".',
     },
   },
   defaultOptions: [
@@ -80,6 +91,7 @@ const sortEnums = createEslintRule({
       ignoreCase: true,
       sortByValue: false,
       partitionByComment: false,
+      partitionByNewLine: false,
       forceNumericSort: false,
     },
   ],
@@ -103,6 +115,7 @@ const sortEnums = createEslintRule({
         let settings = getSettings(context.settings)
         let options = complete(context.options.at(0), settings, {
           partitionByComment: false,
+          partitionByNewLine: false,
           type: 'alphabetical',
           ignoreCase: true,
           order: 'asc',
@@ -139,17 +152,7 @@ const sortEnums = createEslintRule({
         }
         let formattedMembers = members.reduce(
           (accumulator, member) => {
-            let comments = getCommentsBefore(member, sourceCode)
-            if (
-              partitionComment &&
-              hasPartitionComment(partitionComment, comments)
-            ) {
-              accumulator.push([])
-            }
-            let name =
-              member.id.type === 'Literal'
-                ? `${member.id.value}`
-                : `${sourceCode.text.slice(...member.id.range)}`
+            var _a
             let dependencies = []
             if (member.initializer) {
               dependencies = extractDependencies(
@@ -157,11 +160,28 @@ const sortEnums = createEslintRule({
                 node.id.name,
               )
             }
+            let lastSortingNode =
+              (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1)
             let sortingNode = {
               size: rangeToDiff(member.range),
               node: member,
               dependencies,
-              name,
+              name:
+                member.id.type === 'Literal'
+                  ? `${member.id.value}`
+                  : `${sourceCode.text.slice(...member.id.range)}`,
+            }
+            if (
+              (partitionComment &&
+                hasPartitionComment(
+                  partitionComment,
+                  getCommentsBefore(member, sourceCode),
+                )) ||
+              (options.partitionByNewLine &&
+                lastSortingNode &&
+                getLinesBetween(sourceCode, lastSortingNode, sortingNode))
+            ) {
+              accumulator.push([])
             }
             accumulator.at(-1).push(sortingNode)
             return accumulator
@@ -204,29 +224,38 @@ const sortEnums = createEslintRule({
                 }
               : void 0,
         }
-        for (let nodes of formattedMembers) {
-          let sortedNodes = sortNodesByDependencies(
-            sortNodes(nodes, compareOptions),
-          )
-          pairwise(nodes, (left, right) => {
-            let indexOfLeft = sortedNodes.indexOf(left)
-            let indexOfRight = sortedNodes.indexOf(right)
-            if (indexOfLeft > indexOfRight) {
-              context.report({
-                messageId: 'unexpectedEnumsOrder',
-                data: {
-                  left: toSingleLine(left.name),
-                  right: toSingleLine(right.name),
-                },
-                node: right.node,
-                fix: fixer =>
-                  makeFixes(fixer, nodes, sortedNodes, sourceCode, {
-                    partitionComment,
-                  }),
-              })
-            }
-          })
-        }
+        let sortedNodes = sortNodesByDependencies(
+          formattedMembers
+            .map(nodes2 => sortNodes(nodes2, compareOptions))
+            .flat(),
+        )
+        let nodes = formattedMembers.flat()
+        pairwise(nodes, (left, right) => {
+          let indexOfLeft = sortedNodes.indexOf(left)
+          let indexOfRight = sortedNodes.indexOf(right)
+          if (indexOfLeft > indexOfRight) {
+            let firstUnorderedNodeDependentOnRight =
+              getFirstUnorderedNodeDependentOn(right, nodes)
+            context.report({
+              messageId: firstUnorderedNodeDependentOnRight
+                ? 'unexpectedEnumsDependencyOrder'
+                : 'unexpectedEnumsOrder',
+              data: {
+                left: toSingleLine(left.name),
+                right: toSingleLine(right.name),
+                nodeDependentOnRight:
+                  firstUnorderedNodeDependentOnRight == null
+                    ? void 0
+                    : firstUnorderedNodeDependentOnRight.name,
+              },
+              node: right.node,
+              fix: fixer =>
+                makeFixes(fixer, nodes, sortedNodes, sourceCode, {
+                  partitionComment,
+                }),
+            })
+          }
+        })
       }
     },
   }),