eslint-plugin-perfectionist 5.9.1 → 5.10.1

package/dist/index.js

@@ -1,6 +1,5 @@
 import { name, version } from './package.json.js'
 import sort_variable_declarations_default from './rules/sort-variable-declarations.js'
-import sort_union_types_default from './rules/sort-union-types.js'
 import sort_intersection_types_default from './rules/sort-intersection-types.js'
 import sort_import_attributes_default from './rules/sort-import-attributes.js'
 import sort_export_attributes_default from './rules/sort-export-attributes.js'
@@ -10,6 +9,7 @@ import sort_named_imports_default from './rules/sort-named-imports.js'
 import sort_named_exports_default from './rules/sort-named-exports.js'
 import sort_object_types_default from './rules/sort-object-types.js'
 import sort_switch_case_default from './rules/sort-switch-case.js'
+import sort_union_types_default from './rules/sort-union-types.js'
 import sort_interfaces_default from './rules/sort-interfaces.js'
 import sort_decorators_default from './rules/sort-decorators.js'
 import sort_jsx_props_default from './rules/sort-jsx-props.js'

package/dist/package.json.js

@@ -1,3 +1,3 @@
 var name = 'eslint-plugin-perfectionist'
-var version = '5.9.1'
+var version = '5.10.1'
 export { name, version }

package/dist/rules/sort-array-includes.js

@@ -1,6 +1,6 @@
 import {
   buildCommonJsonSchemas,
-  buildUseConfigurationIfJsonSchema,
+  buildUseConfigIfJsonSchema,
   matchesAstSelectorJsonSchema,
 } from '../utils/json-schemas/common-json-schemas.js'
 import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
@@ -51,7 +51,7 @@ var jsonSchema = {
         additionalCustomGroupMatchProperties:
           additionalCustomGroupMatchOptionsJsonSchema,
       }),
-      useConfigurationIf: buildUseConfigurationIfJsonSchema({
+      useConfigurationIf: buildUseConfigIfJsonSchema({
         additionalProperties: {
           matchesAstSelector: matchesAstSelectorJsonSchema,
         },
@@ -122,10 +122,7 @@ function sortPotentiallyValidArray({ matchedAstSelectors, context, node }) {
     if (node.parent.parent.type !== AST_NODE_TYPES.CallExpression) {
       return false
     }
-    if (node.parent.parent.callee !== node.parent) {
-      return false
-    }
-    return true
+    return node.parent.parent.callee === node.parent
   }
 }
 export { sort_array_includes_default as default, defaultOptions, jsonSchema }

package/dist/rules/sort-arrays/compute-node-name.js

@@ -9,7 +9,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils'
  */
 function computeNodeName({ sourceCode, node }) {
   return node.type === AST_NODE_TYPES.Literal ?
-      `${node.value}`
+      String(node.value)
     : sourceCode.getText(node)
 }
 export { computeNodeName }

package/dist/rules/sort-arrays/sort-array.js

@@ -1,12 +1,12 @@
-import { validateNewlinesAndPartitionConfiguration } from '../../utils/validate-newlines-and-partition-configuration.js'
 import { defaultComparatorByOptionsComputer } from '../../utils/compare/default-comparator-by-options-computer.js'
+import { validateNewlinesAndPartitionConfig } from '../../utils/validate-newlines-and-partition-config.js'
 import { buildOptionsByGroupIndexComputer } from '../../utils/build-options-by-group-index-computer.js'
-import { validateCustomSortConfiguration } from '../../utils/validate-custom-sort-configuration.js'
-import { validateGroupsConfiguration } from '../../utils/validate-groups-configuration.js'
+import { validateCustomSortConfig } from '../../utils/validate-custom-sort-config.js'
 import { generatePredefinedGroups } from '../../utils/generate-predefined-groups.js'
 import { getEslintDisabledLines } from '../../utils/get-eslint-disabled-lines.js'
 import { doesCustomGroupMatch } from '../../utils/does-custom-group-match.js'
 import { isNodeEslintDisabled } from '../../utils/is-node-eslint-disabled.js'
+import { validateGroupsConfig } from '../../utils/validate-groups-config.js'
 import { sortNodesByGroups } from '../../utils/sort-nodes-by-groups.js'
 import { reportAllErrors } from '../../utils/report-all-errors.js'
 import { shouldPartition } from '../../utils/should-partition.js'
@@ -47,13 +47,13 @@ function sortArray({
     return
   }
   let options = complete(matchedContextOptions, settings, defaultOptions)
-  validateCustomSortConfiguration(options)
-  validateGroupsConfiguration({
+  validateCustomSortConfig(options)
+  validateGroupsConfig({
     selectors: allSelectors,
     modifiers: [],
     options,
   })
-  validateNewlinesAndPartitionConfiguration(options)
+  validateNewlinesAndPartitionConfig(options)
   let eslintDisabledLines = getEslintDisabledLines({
     ruleName: id,
     sourceCode,
@@ -73,6 +73,11 @@ function sortArray({
         sourceCode,
       })
       let selector = 'literal'
+      let predefinedGroups = generatePredefinedGroups({
+        cache: cachedGroupsByModifiersAndSelectors,
+        selectors: [selector],
+        modifiers: [],
+      })
       let group = computeGroup({
         customGroupMatcher: customGroup =>
           doesCustomGroupMatch({
@@ -81,11 +86,7 @@ function sortArray({
             modifiers: [],
             customGroup,
           }),
-        predefinedGroups: generatePredefinedGroups({
-          cache: cachedGroupsByModifiersAndSelectors,
-          selectors: [selector],
-          modifiers: [],
-        }),
+        predefinedGroups,
         options,
       })
       let sortingNode = {
@@ -125,12 +126,13 @@ function sortArray({
       }),
     )
   }
+  let nodes = formattedMembers.flat()
   reportAllErrors({
     sortNodesExcludingEslintDisabled,
     availableMessageIds,
     options,
     context,
-    nodes: formattedMembers.flat(),
+    nodes,
   })
 }
 export { sortArray }

package/dist/rules/sort-arrays.js

@@ -1,6 +1,6 @@
 import {
   buildCommonJsonSchemas,
-  buildUseConfigurationIfJsonSchema,
+  buildUseConfigIfJsonSchema,
   matchesAstSelectorJsonSchema,
 } from '../utils/json-schemas/common-json-schemas.js'
 import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
@@ -51,7 +51,7 @@ var jsonSchema = {
         additionalCustomGroupMatchProperties:
           additionalCustomGroupMatchOptionsJsonSchema,
       }),
-      useConfigurationIf: buildUseConfigurationIfJsonSchema({
+      useConfigurationIf: buildUseConfigIfJsonSchema({
         additionalProperties: {
           matchesAstSelector: matchesAstSelectorJsonSchema,
         },
@@ -65,6 +65,7 @@ var jsonSchema = {
   },
   uniqueItems: true,
   type: 'array',
+  minItems: 1,
 }
 var sort_arrays_default = createEslintRule({
   meta: {

package/dist/rules/sort-classes/compute-dependencies-by-sorting-node.js

@@ -10,11 +10,12 @@ function computeDependenciesBySortingNode({
   sourceCode,
   classBody,
 }) {
+  let staticSortingNodes = sortingNodes.filter(node => node.isStatic)
   let dependenciesBySortingNode = computeDependenciesBySortingNode$1({
     additionalIdentifierDependenciesComputer:
       buildAdditionalIdentifierDependenciesComputer({
         ignoreCallbackDependenciesPatterns,
-        staticSortingNodes: sortingNodes.filter(node => node.isStatic),
+        staticSortingNodes,
         classBody,
       }),
     shouldIgnoreSortingNodeComputer: sortingNode =>
@@ -73,22 +74,21 @@ function computeIdentifierOrThisExpressionDependency({
     }
   }
   function shouldIgnoreCallbackDependency() {
-    let [firstCallExpressionParent] = computeParentNodesWithTypes({
+    return computeParentNodesWithTypes({
       allowedTypes: [AST_NODE_TYPES.CallExpression],
       maxParent: classElement,
       consecutiveOnly: false,
       node,
-    })
-    if (!firstCallExpressionParent) {
-      return false
-    }
-    if (!('name' in firstCallExpressionParent.callee)) {
-      return false
+    }).some(shouldIgnoreCallExpression)
+    function shouldIgnoreCallExpression(callExpressionParent) {
+      return (
+        'name' in callExpressionParent.callee &&
+        matches(
+          callExpressionParent.callee.name,
+          ignoreCallbackDependenciesPatterns,
+        )
+      )
     }
-    return matches(
-      firstCallExpressionParent.callee.name,
-      ignoreCallbackDependenciesPatterns,
-    )
   }
 }
 function computeThisExpressionDependenciesBySortingNode({
@@ -153,15 +153,15 @@ function shouldIgnoreDependencyComputation(node) {
     case AST_NODE_TYPES.StaticBlock:
       return false
     case AST_NODE_TYPES.TSAbstractAccessorProperty:
-    case AST_NODE_TYPES.AccessorProperty:
-    case AST_NODE_TYPES.MethodDefinition:
-    case AST_NODE_TYPES.TSIndexSignature:
-      return true
     case AST_NODE_TYPES.PropertyDefinition:
+    case AST_NODE_TYPES.AccessorProperty:
       return (
         node.value?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
         node.value?.type === AST_NODE_TYPES.FunctionExpression
       )
+    case AST_NODE_TYPES.MethodDefinition:
+    case AST_NODE_TYPES.TSIndexSignature:
+      return true
     /* v8 ignore next 2 -- @preserve Exhaustive guard. */
     default:
       throw new UnreachableCaseError(node)

package/dist/rules/sort-classes/compute-dependencies.js

@@ -63,9 +63,6 @@ function computeDependencies({
       case AST_NODE_TYPES.Property:
         traverseNode(nodeValue.key)
         traverseNode(nodeValue.value)
-        break
-      default:
-        break
     }
     if ('argument' in nodeValue && nodeValue.argument) {
       traverseNode(nodeValue.argument)

package/dist/rules/sort-classes/compute-identifier-name-details.js

@@ -18,7 +18,7 @@ function computeIdentifierNameDetails(node) {
     case AST_NODE_TYPES.Identifier:
       return buildNonPrivateHashDetails(node.name)
     case AST_NODE_TYPES.Literal:
-      return buildNonPrivateHashDetails(`${node.value}`)
+      return buildNonPrivateHashDetails(String(node.value))
     /* v8 ignore next 2 -- @preserve Exhaustive guard. */
     default:
       throw new UnreachableCaseError(node)

package/dist/rules/sort-classes/compute-matched-context-options.d.ts

@@ -1,6 +1,6 @@
 import { RuleContext } from '@typescript-eslint/utils/ts-eslint'
 import { TSESTree } from '@typescript-eslint/types'
-import { Options } from './types.js'
+import { MessageId, Options } from './types.js'
 /**
  * Computes the matched context options for a given class node.
  *
@@ -10,14 +10,12 @@ import { Options } from './types.js'
  * @param params.context - The rule context.
  * @returns The matched context options or undefined if none match.
  */
-export declare function computeMatchedContextOptions<
-  MessageIds extends string,
->({
+export declare function computeMatchedContextOptions({
   matchedAstSelectors,
   classElements,
   context,
 }: {
-  context: Readonly<RuleContext<MessageIds, Options>>
+  context: Readonly<RuleContext<MessageId, Options>>
   matchedAstSelectors: ReadonlySet<string>
   classElements: TSESTree.ClassElement[]
 }): Options[number] | undefined

package/dist/rules/sort-classes/compute-overload-signature-groups.js

@@ -41,10 +41,11 @@ function computeOverloadSignatureGroups(classElements) {
 }
 function buildOverloadSignatureGroup(methods) {
   let implementation = methods.find(isMethodImplementation) ?? methods.at(-1)
+  let overloadSignatures = methods.filter(
+    method => !isMethodImplementation(method),
+  )
   return new OverloadSignatureGroup({
-    overloadSignatures: methods.filter(
-      method => !isMethodImplementation(method),
-    ),
+    overloadSignatures,
     implementation,
   })
   function isMethodImplementation(method) {

package/dist/rules/sort-classes/node-info/common-modifiers.d.ts

@@ -1,8 +1,7 @@
 import { TSESTree } from '@typescript-eslint/types'
 import { Modifier } from '../types.js'
 type Property =
-  | TSESTree.TSAbstractPropertyDefinition
-  | TSESTree.PropertyDefinition
+  TSESTree.TSAbstractPropertyDefinition | TSESTree.PropertyDefinition
 type Accessor = TSESTree.TSAbstractAccessorProperty | TSESTree.AccessorProperty
 type Method = TSESTree.TSAbstractMethodDefinition | TSESTree.MethodDefinition
 export declare function computeAccessibilityModifier({

package/dist/rules/sort-classes/node-info/compute-accessor-details.d.ts

@@ -1,26 +1,39 @@
 import { TSESTree } from '@typescript-eslint/types'
 import { TSESLint } from '@typescript-eslint/utils'
 import { NodeNameDetails, Modifier, Selector } from '../types.js'
+import { RegexOption } from '../../../types/common-options.js'
 /**
  * Computes details related to an accessor property.
  *
  * @param params - Parameters object.
  * @param params.isDecorated - Whether the accessor is decorated.
+ * @param params.ignoreCallbackDependenciesPatterns - Patterns to ignore when
+ *   computing dependencies.
+ * @param params.useExperimentalDependencyDetection - Whether to use
+ *   experimental dependency detection.
  * @param params.sourceCode - The source code object.
+ * @param params.className - The name of the class containing the accessor.
  * @param params.accessor - The accessor node to compute information for.
  * @returns An object containing various details about the accessor.
  */
 export declare function computeAccessorDetails({
+  ignoreCallbackDependenciesPatterns,
+  useExperimentalDependencyDetection,
   isDecorated,
   sourceCode,
+  className,
   accessor,
 }: {
   accessor: TSESTree.TSAbstractAccessorProperty | TSESTree.AccessorProperty
+  ignoreCallbackDependenciesPatterns: RegexOption
+  useExperimentalDependencyDetection: boolean
   sourceCode: TSESLint.SourceCode
+  className: undefined | string
   isDecorated: boolean
 }): {
   nameDetails: NodeNameDetails
   dependencyNames: string[]
+  dependencies: string[]
   modifiers: Modifier[]
   selectors: Selector[]
   isStatic: boolean

package/dist/rules/sort-classes/node-info/compute-accessor-details.js

@@ -6,17 +6,31 @@ import {
   computeStaticModifier,
 } from './common-modifiers.js'
 import { computeDependencyName } from '../compute-dependency-name.js'
+import { computeDependencies } from '../compute-dependencies.js'
 import { computeMethodOrPropertyNameDetails } from './compute-method-or-property-name-details.js'
+import { isFunctionExpression } from './is-function-expression.js'
 /**
  * Computes details related to an accessor property.
  *
  * @param params - Parameters object.
  * @param params.isDecorated - Whether the accessor is decorated.
+ * @param params.ignoreCallbackDependenciesPatterns - Patterns to ignore when
+ *   computing dependencies.
+ * @param params.useExperimentalDependencyDetection - Whether to use
+ *   experimental dependency detection.
  * @param params.sourceCode - The source code object.
+ * @param params.className - The name of the class containing the accessor.
  * @param params.accessor - The accessor node to compute information for.
  * @returns An object containing various details about the accessor.
  */
-function computeAccessorDetails({ isDecorated, sourceCode, accessor }) {
+function computeAccessorDetails({
+  ignoreCallbackDependenciesPatterns,
+  useExperimentalDependencyDetection,
+  isDecorated,
+  sourceCode,
+  className,
+  accessor,
+}) {
   let nameDetails = computeMethodOrPropertyNameDetails(accessor, sourceCode)
   let modifiers = computeModifiers({
     hasPrivateHash: nameDetails.hasPrivateHash,
@@ -31,12 +45,38 @@ function computeAccessorDetails({ isDecorated, sourceCode, accessor }) {
         isStatic: modifiers.includes('static'),
       }),
     ],
+    dependencies: computeAccessorDependencies({
+      ignoreCallbackDependenciesPatterns,
+      useExperimentalDependencyDetection,
+      className,
+      accessor,
+    }),
     selectors: ['accessor-property'],
     isStatic: accessor.static,
     nameDetails,
     modifiers,
   }
 }
+function computeAccessorDependencies({
+  ignoreCallbackDependenciesPatterns,
+  useExperimentalDependencyDetection,
+  className,
+  accessor,
+}) {
+  if (isFunctionExpression(accessor.value)) {
+    return []
+  }
+  if (!accessor.value) {
+    return []
+  }
+  return computeDependencies({
+    ignoreCallbackDependenciesPatterns,
+    useExperimentalDependencyDetection,
+    isMemberStatic: accessor.static,
+    expression: accessor.value,
+    className,
+  })
+}
 function computeModifiers({ hasPrivateHash, isDecorated, accessor }) {
   return [
     ...computeStaticModifier(accessor),

package/dist/rules/sort-classes/node-info/compute-property-details.js

@@ -11,7 +11,7 @@ import {
 import { computeDependencyName } from '../compute-dependency-name.js'
 import { computeDependencies } from '../compute-dependencies.js'
 import { computeMethodOrPropertyNameDetails } from './compute-method-or-property-name-details.js'
-import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import { isFunctionExpression } from './is-function-expression.js'
 /**
  * Computes details related to a property.
  *
@@ -115,13 +115,4 @@ function computeSelectors(property) {
     return isFunctionExpression(property.value) ? ['function-property'] : []
   }
 }
-function isFunctionExpression(node) {
-  if (!node) {
-    return false
-  }
-  return (
-    node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
-    node.type === AST_NODE_TYPES.FunctionExpression
-  )
-}
 export { computePropertyDetails }

package/dist/rules/sort-classes/node-info/is-function-expression.d.ts

@@ -0,0 +1,11 @@
+import { TSESTree } from '@typescript-eslint/types'
+/**
+ * Checks whether a node is a function expression or an arrow function
+ * expression.
+ *
+ * @param node - The AST node to check.
+ * @returns Whether the node is a function expression.
+ */
+export declare function isFunctionExpression(
+  node: TSESTree.Node | null,
+): node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression

package/dist/rules/sort-classes/node-info/is-function-expression.js

@@ -0,0 +1,18 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+/**
+ * Checks whether a node is a function expression or an arrow function
+ * expression.
+ *
+ * @param node - The AST node to check.
+ * @returns Whether the node is a function expression.
+ */
+function isFunctionExpression(node) {
+  if (!node) {
+    return false
+  }
+  return (
+    node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+    node.type === AST_NODE_TYPES.FunctionExpression
+  )
+}
+export { isFunctionExpression }

package/dist/rules/sort-classes/sort-class.js

@@ -1,16 +1,16 @@
 import { UnreachableCaseError } from '../../utils/unreachable-case-error.js'
 import { getGroupIndex } from '../../utils/get-group-index.js'
 import { populateSortingNodeGroupsWithDependencies } from '../../utils/populate-sorting-node-groups-with-dependencies.js'
-import { validateNewlinesAndPartitionConfiguration } from '../../utils/validate-newlines-and-partition-configuration.js'
 import { defaultComparatorByOptionsComputer } from '../../utils/compare/default-comparator-by-options-computer.js'
+import { validateNewlinesAndPartitionConfig } from '../../utils/validate-newlines-and-partition-config.js'
 import { buildOptionsByGroupIndexComputer } from '../../utils/build-options-by-group-index-computer.js'
-import { validateCustomSortConfiguration } from '../../utils/validate-custom-sort-configuration.js'
-import { validateGroupsConfiguration } from '../../utils/validate-groups-configuration.js'
+import { validateCustomSortConfig } from '../../utils/validate-custom-sort-config.js'
 import { generatePredefinedGroups } from '../../utils/generate-predefined-groups.js'
 import { sortNodesByDependencies } from '../../utils/sort-nodes-by-dependencies.js'
 import { getEslintDisabledLines } from '../../utils/get-eslint-disabled-lines.js'
 import { doesCustomGroupMatch } from '../../utils/does-custom-group-match.js'
 import { isNodeEslintDisabled } from '../../utils/is-node-eslint-disabled.js'
+import { validateGroupsConfig } from '../../utils/validate-groups-config.js'
 import { sortNodesByGroups } from '../../utils/sort-nodes-by-groups.js'
 import { reportAllErrors } from '../../utils/report-all-errors.js'
 import { shouldPartition } from '../../utils/should-partition.js'
@@ -94,22 +94,19 @@ function sortClass({ matchedAstSelectors, context, node }) {
     return
   }
   let settings = getSettings(context.settings)
-  let options = complete(
-    computeMatchedContextOptions({
-      matchedAstSelectors,
-      classElements,
-      context,
-    }),
-    settings,
-    defaultOptions,
-  )
-  validateCustomSortConfiguration(options)
-  validateGroupsConfiguration({
+  let matchedContextOptions = computeMatchedContextOptions({
+    matchedAstSelectors,
+    classElements,
+    context,
+  })
+  let options = complete(matchedContextOptions, settings, defaultOptions)
+  validateCustomSortConfig(options)
+  validateGroupsConfig({
     modifiers: allModifiers,
     selectors: allSelectors,
     options,
   })
-  validateNewlinesAndPartitionConfiguration(options)
+  validateNewlinesAndPartitionConfig(options)
   let { sourceCode, id } = context
   let eslintDisabledLines = getEslintDisabledLines({
     ruleName: id,
@@ -125,15 +122,15 @@ function sortClass({ matchedAstSelectors, context, node }) {
     (accumulator, member) => {
       let dependencies = []
       let isDecorated = false
-      let decorators = []
+      let decoratorNames = []
       if ('decorators' in member) {
-        decorators = getNodeDecorators(member).map(decorator =>
+        decoratorNames = getNodeDecorators(member).map(decorator =>
           getDecoratorName({
             sourceCode,
             decorator,
           }),
         )
-        isDecorated = decorators.length > 0
+        isDecorated = decoratorNames.length > 0
       }
       let addSafetySemicolonWhenInline
       let dependencyNames
@@ -187,12 +184,23 @@ function sortClass({ matchedAstSelectors, context, node }) {
         case AST_NODE_TYPES.TSAbstractAccessorProperty:
         case AST_NODE_TYPES.AccessorProperty:
           addSafetySemicolonWhenInline = true
-          ;({ dependencyNames, nameDetails, selectors, modifiers, isStatic } =
-            computeAccessorDetails({
-              accessor: member,
-              isDecorated,
-              sourceCode,
-            }))
+          ;({
+            dependencyNames,
+            dependencies,
+            nameDetails,
+            modifiers,
+            selectors,
+            isStatic,
+          } = computeAccessorDetails({
+            ignoreCallbackDependenciesPatterns:
+              options.ignoreCallbackDependenciesPatterns,
+            useExperimentalDependencyDetection:
+              options.useExperimentalDependencyDetection,
+            accessor: member,
+            isDecorated,
+            sourceCode,
+            className,
+          }))
           ;({ name } = nameDetails)
           break
         case AST_NODE_TYPES.TSIndexSignature:
@@ -224,21 +232,22 @@ function sortClass({ matchedAstSelectors, context, node }) {
         default:
           throw new UnreachableCaseError(member)
       }
+      let predefinedGroups = generatePredefinedGroups({
+        cache: cachedGroupsByModifiersAndSelectors,
+        selectors,
+        modifiers,
+      })
       let group = computeGroup({
         customGroupMatcher: customGroup =>
           doesCustomGroupMatch({
             elementValue: memberValue,
             elementName: name,
+            decoratorNames,
             customGroup,
-            decorators,
             modifiers,
             selectors,
           }),
-        predefinedGroups: generatePredefinedGroups({
-          cache: cachedGroupsByModifiersAndSelectors,
-          selectors,
-          modifiers,
-        }),
+        predefinedGroups,
         options,
       })
       let sortingNode = {
@@ -277,14 +286,15 @@ function sortClass({ matchedAstSelectors, context, node }) {
     sortingNodeGroups: sortingNodeGroupsWithoutOverloadSignature,
   })
   if (options.useExperimentalDependencyDetection) {
+    let dependenciesBySortingNode = computeDependenciesBySortingNode({
+      ignoreCallbackDependenciesPatterns:
+        options.ignoreCallbackDependenciesPatterns,
+      sortingNodes: sortingNodeGroups.flat(),
+      classBody: node,
+      sourceCode,
+    })
     sortingNodeGroups = populateSortingNodeGroupsWithDependencies({
-      dependenciesBySortingNode: computeDependenciesBySortingNode({
-        ignoreCallbackDependenciesPatterns:
-          options.ignoreCallbackDependenciesPatterns,
-        sortingNodes: sortingNodeGroups.flat(),
-        classBody: node,
-        sourceCode,
-      }),
+      dependenciesBySortingNode,
       sortingNodeGroups,
     })
   }
@@ -304,21 +314,20 @@ function sortClass({ matchedAstSelectors, context, node }) {
     context,
   })
   function sortNodesExcludingEslintDisabled(ignoreEslintDisabledNodes) {
-    return sortNodesByDependencies(
-      sortingNodeGroups.flatMap(sortingNodeGroup =>
-        sortNodesByGroups({
-          isNodeIgnored: sortingNode =>
-            getGroupIndex(options.groups, sortingNode) ===
-            options.groups.length,
-          comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
-          optionsByGroupIndexComputer,
-          ignoreEslintDisabledNodes,
-          nodes: sortingNodeGroup,
-          groups: options.groups,
-        }),
-      ),
-      { ignoreEslintDisabledNodes },
+    let nodesSortedByGroups = sortingNodeGroups.flatMap(sortingNodeGroup =>
+      sortNodesByGroups({
+        isNodeIgnored: sortingNode =>
+          getGroupIndex(options.groups, sortingNode) === options.groups.length,
+        comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
+        optionsByGroupIndexComputer,
+        ignoreEslintDisabledNodes,
+        nodes: sortingNodeGroup,
+        groups: options.groups,
+      }),
     )
+    return sortNodesByDependencies(nodesSortedByGroups, {
+      ignoreEslintDisabledNodes,
+    })
   }
 }
 export { defaultOptions, sortClass }

package/dist/rules/sort-classes/types.d.ts

@@ -61,9 +61,7 @@ export type Options = Partial<
 >[]
 export interface SortClassesSortingNode extends SortingNodeWithDependencies<TSESTree.ClassElement> {
   overloadSignatureImplementation:
-    | TSESTree.TSAbstractMethodDefinition
-    | TSESTree.MethodDefinition
-    | null
+    TSESTree.TSAbstractMethodDefinition | TSESTree.MethodDefinition | null
   nameDetails: NodeNameDetails | null
   isStatic: boolean
 }