eslint-plugin-perfectionist 5.3.0 → 5.4.0

package/dist/rules/sort-enums.js

@@ -10,18 +10,24 @@ import {
   partitionByNewLineJsonSchema,
   partitionByCommentJsonSchema,
 } from '../utils/json-schemas/common-partition-json-schemas.js'
+import {
+  useExperimentalDependencyDetectionJsonSchema,
+  buildCommonJsonSchemas,
+} from '../utils/json-schemas/common-json-schemas.js'
+import { populateSortingNodeGroupsWithDependencies } from '../utils/populate-sorting-node-groups-with-dependencies.js'
 import { validateNewlinesAndPartitionConfiguration } from '../utils/validate-newlines-and-partition-configuration.js'
-import { buildDefaultOptionsByGroupIndexComputer } from '../utils/build-default-options-by-group-index-computer.js'
 import { buildComparatorByOptionsComputer } from './sort-enums/build-comparator-by-options-computer.js'
+import { computeDependenciesBySortingNode } from './sort-enums/compute-dependencies-by-sorting-node.js'
+import { buildOptionsByGroupIndexComputer } from '../utils/build-options-by-group-index-computer.js'
 import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
 import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration.js'
 import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.js'
-import { buildCommonJsonSchemas } from '../utils/json-schemas/common-json-schemas.js'
 import { additionalCustomGroupMatchOptionsJsonSchema } from './sort-enums/types.js'
 import { sortNodesByDependencies } from '../utils/sort-nodes-by-dependencies.js'
 import { getEslintDisabledLines } from '../utils/get-eslint-disabled-lines.js'
 import { isNodeEslintDisabled } from '../utils/is-node-eslint-disabled.js'
 import { doesCustomGroupMatch } from '../utils/does-custom-group-match.js'
+import { computeDependencies } from './sort-enums/compute-dependencies.js'
 import { sortNodesByGroups } from '../utils/sort-nodes-by-groups.js'
 import { createEslintRule } from '../utils/create-eslint-rule.js'
 import { reportAllErrors } from '../utils/report-all-errors.js'
@@ -38,6 +44,7 @@ const EXTRA_SPACING_ERROR_ID = 'extraSpacingBetweenEnumsMembers'
 const MISSED_SPACING_ERROR_ID = 'missedSpacingBetweenEnumsMembers'
 const DEPENDENCY_ORDER_ERROR_ID = 'unexpectedEnumsDependencyOrder'
 let defaultOptions = {
+  useExperimentalDependencyDetection: true,
   fallbackSort: { type: 'unsorted' },
   newlinesInside: 'newlinesBetween',
   sortByValue: 'ifNumericEnum',
@@ -77,39 +84,10 @@ const sortEnums = createEslintRule({
         ruleName: id,
         sourceCode,
       })
-      function extractDependencies(expression, enumName) {
-        let dependencies = []
-        let stack = [expression]
-        while (stack.length > 0) {
-          let node = stack.pop()
-          if (
-            node.type === AST_NODE_TYPES.MemberExpression &&
-            node.object.type === AST_NODE_TYPES.Identifier &&
-            node.object.name === enumName &&
-            node.property.type === AST_NODE_TYPES.Identifier
-          ) {
-            dependencies.push(node.property.name)
-          } else if (node.type === AST_NODE_TYPES.Identifier) {
-            dependencies.push(node.name)
-          }
-          if ('left' in node) {
-            stack.push(node.left)
-          }
-          if ('right' in node) {
-            stack.push(node.right)
-          }
-          if ('expressions' in node) {
-            stack.push(...node.expressions)
-          }
-        }
-        return dependencies
-      }
-      let formattedMembers = members.reduce(
+      let optionsByGroupIndexComputer =
+        buildOptionsByGroupIndexComputer(options)
+      let sortingNodeGroups = members.reduce(
         (accumulator, member) => {
-          let dependencies = extractDependencies(
-            member.initializer,
-            enumDeclaration.id.name,
-          )
           let name =
             member.id.type === AST_NODE_TYPES.Literal
               ? member.id.value
@@ -128,6 +106,12 @@ const sortEnums = createEslintRule({
           })
           let lastSortingNode = accumulator.at(-1)?.at(-1)
           let sortingNode = {
+            dependencies: options.useExperimentalDependencyDetection
+              ? []
+              : computeDependencies(
+                  member.initializer,
+                  enumDeclaration.id.name,
+                ),
             value:
               member.initializer?.type === AST_NODE_TYPES.Literal
                 ? (member.initializer.value?.toString() ?? null)
@@ -137,7 +121,6 @@ const sortEnums = createEslintRule({
             size: rangeToDiff(member, sourceCode),
             dependencyNames: [name],
             node: member,
-            dependencies,
             group,
             name,
           }
@@ -159,26 +142,21 @@ const sortEnums = createEslintRule({
         },
         [[]],
       )
-      let nodes = formattedMembers.flat()
-      let isNumericEnum = nodes.every(
-        sortingNode => sortingNode.numericValue !== null,
-      )
-      function sortNodesExcludingEslintDisabled(ignoreEslintDisabledNodes) {
-        let nodesSortedByGroups = formattedMembers.flatMap(sortingNodes =>
-          sortNodesByGroups({
-            optionsByGroupIndexComputer:
-              buildDefaultOptionsByGroupIndexComputer(options),
-            comparatorByOptionsComputer:
-              buildComparatorByOptionsComputer(isNumericEnum),
-            ignoreEslintDisabledNodes,
-            groups: options.groups,
-            nodes: sortingNodes,
-          }),
-        )
-        return sortNodesByDependencies(nodesSortedByGroups, {
-          ignoreEslintDisabledNodes,
+      if (options.useExperimentalDependencyDetection) {
+        let dependenciesBySortingNode = computeDependenciesBySortingNode({
+          sortingNodes: sortingNodeGroups.flat(),
+          enumName: enumDeclaration.id.name,
+          sourceCode,
+        })
+        sortingNodeGroups = populateSortingNodeGroupsWithDependencies({
+          dependenciesBySortingNode,
+          sortingNodeGroups,
         })
       }
+      let sortingNodes = sortingNodeGroups.flat()
+      let isNumericEnum = sortingNodes.every(
+        sortingNode => sortingNode.numericValue !== null,
+      )
       reportAllErrors({
         availableMessageIds: {
           missedSpacingBetweenMembers: MISSED_SPACING_ERROR_ID,
@@ -188,10 +166,25 @@ const sortEnums = createEslintRule({
           unexpectedOrder: ORDER_ERROR_ID,
         },
         sortNodesExcludingEslintDisabled,
+        nodes: sortingNodes,
         options,
         context,
-        nodes,
       })
+      function sortNodesExcludingEslintDisabled(ignoreEslintDisabledNodes) {
+        let nodesSortedByGroups = sortingNodeGroups.flatMap(sortingNodeGroup =>
+          sortNodesByGroups({
+            comparatorByOptionsComputer:
+              buildComparatorByOptionsComputer(isNumericEnum),
+            optionsByGroupIndexComputer,
+            ignoreEslintDisabledNodes,
+            nodes: sortingNodeGroup,
+            groups: options.groups,
+          }),
+        )
+        return sortNodesByDependencies(nodesSortedByGroups, {
+          ignoreEslintDisabledNodes,
+        })
+      }
     },
   }),
   meta: {
@@ -208,6 +201,8 @@ const sortEnums = createEslintRule({
             enum: ['always', 'ifNumericEnum', 'never'],
             type: 'string',
           },
+          useExperimentalDependencyDetection:
+            useExperimentalDependencyDetectionJsonSchema,
           partitionByComment: partitionByCommentJsonSchema,
           partitionByNewLine: partitionByNewLineJsonSchema,
         },

package/dist/rules/sort-export-attributes.js

@@ -10,8 +10,8 @@ import {
   MISSED_SPACING_ERROR,
 } from '../utils/report-errors.js'
 import { validateNewlinesAndPartitionConfiguration } from '../utils/validate-newlines-and-partition-configuration.js'
-import { buildDefaultOptionsByGroupIndexComputer } from '../utils/build-default-options-by-group-index-computer.js'
 import { defaultComparatorByOptionsComputer } from '../utils/compare/default-comparator-by-options-computer.js'
+import { buildOptionsByGroupIndexComputer } from '../utils/build-options-by-group-index-computer.js'
 import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
 import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration.js'
 import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.js'
@@ -68,6 +68,8 @@ const sortExportAttributes = createEslintRule({
         ruleName: id,
         sourceCode,
       })
+      let optionsByGroupIndexComputer =
+        buildOptionsByGroupIndexComputer(options)
       let formattedMembers = [[]]
       for (let attribute of attributes) {
         let name = getAttributeName(attribute, sourceCode)
@@ -112,9 +114,8 @@ const sortExportAttributes = createEslintRule({
         let createSortNodesExcludingEslintDisabled = function (sortingNodes) {
           return function (ignoreEslintDisabledNodes) {
             return sortNodesByGroups({
-              optionsByGroupIndexComputer:
-                buildDefaultOptionsByGroupIndexComputer(options),
               comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
+              optionsByGroupIndexComputer,
               ignoreEslintDisabledNodes,
               groups: options.groups,
               nodes: sortingNodes,

package/dist/rules/sort-exports.js

@@ -16,8 +16,8 @@ import {
   allModifiers,
 } from './sort-exports/types.js'
 import { validateNewlinesAndPartitionConfiguration } from '../utils/validate-newlines-and-partition-configuration.js'
-import { buildDefaultOptionsByGroupIndexComputer } from '../utils/build-default-options-by-group-index-computer.js'
 import { defaultComparatorByOptionsComputer } from '../utils/compare/default-comparator-by-options-computer.js'
+import { buildOptionsByGroupIndexComputer } from '../utils/build-options-by-group-index-computer.js'
 import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
 import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration.js'
 import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.js'
@@ -174,8 +174,7 @@ const sortExports = createEslintRule({
   name: 'sort-exports',
 })
 function sortExportNodes({ formattedMembers, context, options }) {
-  let optionsByGroupIndexComputer =
-    buildDefaultOptionsByGroupIndexComputer(options)
+  let optionsByGroupIndexComputer = buildOptionsByGroupIndexComputer(options)
   let nodes = formattedMembers.flat()
   reportAllErrors({
     availableMessageIds: {

package/dist/rules/sort-heritage-clauses.js

@@ -10,8 +10,8 @@ import {
   MISSED_SPACING_ERROR,
 } from '../utils/report-errors.js'
 import { validateNewlinesAndPartitionConfiguration } from '../utils/validate-newlines-and-partition-configuration.js'
-import { buildDefaultOptionsByGroupIndexComputer } from '../utils/build-default-options-by-group-index-computer.js'
 import { defaultComparatorByOptionsComputer } from '../utils/compare/default-comparator-by-options-computer.js'
+import { buildOptionsByGroupIndexComputer } from '../utils/build-options-by-group-index-computer.js'
 import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
 import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration.js'
 import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.js'
@@ -106,6 +106,7 @@ function sortHeritageClauses$1(context, options, heritageClauses) {
     ruleName: id,
     sourceCode,
   })
+  let optionsByGroupIndexComputer = buildOptionsByGroupIndexComputer(options)
   let formattedMembers = [[]]
   for (let heritageClause of heritageClauses) {
     let name = getHeritageClauseExpressionName(heritageClause.expression)
@@ -148,9 +149,8 @@ function sortHeritageClauses$1(context, options, heritageClauses) {
     let createSortNodesExcludingEslintDisabled = function (sortingNodes) {
       return function (ignoreEslintDisabledNodes) {
         return sortNodesByGroups({
-          optionsByGroupIndexComputer:
-            buildDefaultOptionsByGroupIndexComputer(options),
           comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
+          optionsByGroupIndexComputer,
           ignoreEslintDisabledNodes,
           groups: options.groups,
           nodes: sortingNodes,

package/dist/rules/sort-import-attributes.js

@@ -10,8 +10,8 @@ import {
   MISSED_SPACING_ERROR,
 } from '../utils/report-errors.js'
 import { validateNewlinesAndPartitionConfiguration } from '../utils/validate-newlines-and-partition-configuration.js'
-import { buildDefaultOptionsByGroupIndexComputer } from '../utils/build-default-options-by-group-index-computer.js'
 import { defaultComparatorByOptionsComputer } from '../utils/compare/default-comparator-by-options-computer.js'
+import { buildOptionsByGroupIndexComputer } from '../utils/build-options-by-group-index-computer.js'
 import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
 import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration.js'
 import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.js'
@@ -68,6 +68,8 @@ const sortImportAttributes = createEslintRule({
         ruleName: id,
         sourceCode,
       })
+      let optionsByGroupIndexComputer =
+        buildOptionsByGroupIndexComputer(options)
       let formattedMembers = [[]]
       for (let attribute of attributes) {
         let name = getAttributeName(attribute, sourceCode)
@@ -112,9 +114,8 @@ const sortImportAttributes = createEslintRule({
         let createSortNodesExcludingEslintDisabled = function (sortingNodes) {
           return function (ignoreEslintDisabledNodes) {
             return sortNodesByGroups({
-              optionsByGroupIndexComputer:
-                buildDefaultOptionsByGroupIndexComputer(options),
               comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
+              optionsByGroupIndexComputer,
               ignoreEslintDisabledNodes,
               groups: options.groups,
               nodes: sortingNodes,

package/dist/rules/sort-imports/comparator-by-options-computer.js

@@ -10,7 +10,6 @@ let comparatorByOptionsComputer = options => {
   switch (options.type) {
     case 'type-import-first':
       return (a, b) => compareTypeImportFirst(a, b, options)
-    /* v8 ignore next -- @preserve Untested for now as not a relevant sort for this rule. */
     case 'subgroup-order':
     case 'alphabetical':
     case 'line-length':

package/dist/rules/sort-imports/compute-dependencies.d.ts

@@ -1,13 +1,10 @@
-import { TSESTree } from '@typescript-eslint/types'
+import { SortImportsNode } from './types.js'
 /**
  * Computes the dependencies of an import-like AST node.
  *
+ * @deprecated - To remove when experimental dependency detection is the only
+ *   option.
  * @param node - The AST node representing an import-like declaration.
  * @returns The names of the dependencies.
  */
-export declare function computeDependencies(
-  node:
-    | TSESTree.TSImportEqualsDeclaration
-    | TSESTree.VariableDeclaration
-    | TSESTree.ImportDeclaration,
-): string[]
+export declare function computeDependencies(node: SortImportsNode): string[]

package/dist/rules/sort-imports/compute-dependency-names.d.ts

@@ -1,5 +1,5 @@
-import { TSESTree } from '@typescript-eslint/types'
 import { TSESLint } from '@typescript-eslint/utils'
+import { SortImportsNode } from './types.js'
 /**
  * Computes the dependency names of an import-like AST node.
  *
@@ -12,9 +12,6 @@ export declare function computeDependencyNames({
   sourceCode,
   node,
 }: {
-  node:
-    | TSESTree.TSImportEqualsDeclaration
-    | TSESTree.VariableDeclaration
-    | TSESTree.ImportDeclaration
   sourceCode: TSESLint.SourceCode
+  node: SortImportsNode
 }): string[]

package/dist/rules/sort-imports/compute-node-name.d.ts

@@ -1,5 +1,5 @@
-import { TSESTree } from '@typescript-eslint/types'
 import { TSESLint } from '@typescript-eslint/utils'
+import { SortImportsNode } from './types.js'
 /**
  * Computes the name of an import-like AST node.
  *
@@ -12,9 +12,6 @@ export declare function computeNodeName({
   sourceCode,
   node,
 }: {
-  node:
-    | TSESTree.TSImportEqualsDeclaration
-    | TSESTree.VariableDeclaration
-    | TSESTree.ImportDeclaration
   sourceCode: TSESLint.SourceCode
+  node: SortImportsNode
 }): string

package/dist/rules/sort-imports/compute-specifier-modifiers.d.ts

@@ -1,4 +1,4 @@
-import { TSESTree } from '@typescript-eslint/types'
+import { SortImportsNode } from './types.js'
 type Modifier = 'wildcard' | 'default' | 'named'
 /**
  * Computes the specifier modifiers of an import-like AST node.
@@ -7,9 +7,6 @@ type Modifier = 'wildcard' | 'default' | 'named'
  * @returns A list of specifier modifiers.
  */
 export declare function computeSpecifierModifiers(
-  node:
-    | TSESTree.TSImportEqualsDeclaration
-    | TSESTree.VariableDeclaration
-    | TSESTree.ImportDeclaration,
+  node: SortImportsNode,
 ): Modifier[]
 export {}

package/dist/rules/sort-imports/compute-specifier-name.d.ts

@@ -1,12 +1,9 @@
 import { TSESLint } from '@typescript-eslint/utils'
-import { TSESTree } from '@typescript-eslint/types'
+import { SortImportsNode } from './types.js'
 export declare function computeSpecifierName({
   sourceCode,
   node,
 }: {
-  node:
-    | TSESTree.TSImportEqualsDeclaration
-    | TSESTree.VariableDeclaration
-    | TSESTree.ImportDeclaration
   sourceCode: TSESLint.SourceCode
+  node: SortImportsNode
 }): string | null

package/dist/rules/sort-imports/is-non-external-reference-ts-import-equals.d.ts

@@ -1,4 +1,5 @@
 import { TSESTree } from '@typescript-eslint/types'
+import { SortImportsNode } from './types.js'
 /**
  * Determines whether the given AST node is a non-external-reference TS import
  * equals declaration.
@@ -8,8 +9,5 @@ import { TSESTree } from '@typescript-eslint/types'
  *   declaration; otherwise, false.
  */
 export declare function isNonExternalReferenceTsImportEquals(
-  node:
-    | TSESTree.TSImportEqualsDeclaration
-    | TSESTree.VariableDeclaration
-    | TSESTree.ImportDeclaration,
+  node: SortImportsNode,
 ): node is TSESTree.TSImportEqualsDeclaration

package/dist/rules/sort-imports/is-side-effect-import.d.ts

@@ -1,5 +1,5 @@
 import { TSESLint } from '@typescript-eslint/utils'
-import { TSESTree } from '@typescript-eslint/types'
+import { SortImportsNode } from './types.js'
 /**
  * Determines whether the given AST node is a side-effect import.
  *
@@ -12,9 +12,6 @@ export declare function isSideEffectImport({
   sourceCode,
   node,
 }: {
-  node:
-    | TSESTree.TSImportEqualsDeclaration
-    | TSESTree.VariableDeclaration
-    | TSESTree.ImportDeclaration
   sourceCode: TSESLint.SourceCode
+  node: SortImportsNode
 }): boolean

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

@@ -24,6 +24,8 @@ export type Options = Partial<
       /** Root directory where to search for the TypeScript config file. */
       rootDir: string
     }
+    /** Enables experimental dependency detection. */
+    useExperimentalDependencyDetection: boolean
     /**
      * Patterns to identify internal imports. Imports matching these patterns
      * are categorized as 'internal'.
@@ -58,11 +60,7 @@ export type Options = Partial<
  * Represents a sorting node for an import statement. Extends the base sorting
  * node with dependency information and ignore flag.
  */
-export interface SortImportsSortingNode extends SortingNodeWithDependencies<
-  | TSESTree.TSImportEqualsDeclaration
-  | TSESTree.VariableDeclaration
-  | TSESTree.ImportDeclaration
-> {
+export interface SortImportsSortingNode extends SortingNodeWithDependencies<SortImportsNode> {
   /** The name of the import specifier for sorting purposes. */
   specifierName: string | null
   /** Whether this import is a type-only import. */
@@ -73,6 +71,10 @@ export interface SortImportsSortingNode extends SortingNodeWithDependencies<
    */
   isIgnored: boolean
 }
+export type SortImportsNode =
+  | TSESTree.TSImportEqualsDeclaration
+  | TSESTree.VariableDeclaration
+  | TSESTree.ImportDeclaration
 export type CustomTypeOption = 'type-import-first' | TypeOption
 /**
  * Union type of all available import selectors. Used to categorize different

package/dist/rules/sort-imports.js

@@ -14,18 +14,21 @@ import {
   DEPENDENCY_ORDER_ERROR,
   MISSED_COMMENT_ABOVE_ERROR,
 } from '../utils/report-errors.js'
+import {
+  buildRegexJsonSchema,
+  useExperimentalDependencyDetectionJsonSchema,
+  buildCommonJsonSchemas,
+} from '../utils/json-schemas/common-json-schemas.js'
 import {
   partitionByNewLineJsonSchema,
   partitionByCommentJsonSchema,
 } from '../utils/json-schemas/common-partition-json-schemas.js'
+import { populateSortingNodeGroupsWithDependencies } from '../utils/populate-sorting-node-groups-with-dependencies.js'
 import { validateNewlinesAndPartitionConfiguration } from '../utils/validate-newlines-and-partition-configuration.js'
-import { buildDefaultOptionsByGroupIndexComputer } from '../utils/build-default-options-by-group-index-computer.js'
 import { isNonExternalReferenceTsImportEquals } from './sort-imports/is-non-external-reference-ts-import-equals.js'
-import {
-  buildRegexJsonSchema,
-  buildCommonJsonSchemas,
-} from '../utils/json-schemas/common-json-schemas.js'
 import { validateSideEffectsConfiguration } from './sort-imports/validate-side-effects-configuration.js'
+import { buildOptionsByGroupIndexComputer } from '../utils/build-options-by-group-index-computer.js'
+import { computeDependenciesBySortingNode } from '../utils/compute-dependencies-by-sorting-node.js'
 import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
 import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration.js'
 import { comparatorByOptionsComputer } from './sort-imports/comparator-by-options-computer.js'
@@ -73,6 +76,7 @@ let defaultOptions = {
     'ts-equals-import',
     'unknown',
   ],
+  useExperimentalDependencyDetection: true,
   internalPattern: ['^~/.+', '^@/.+'],
   fallbackSort: { type: 'unsorted' },
   partitionByComment: false,
@@ -200,11 +204,13 @@ const sortImports = createEslintRule({
           isSideEffect &&
           !shouldRegroupSideEffectNodes &&
           (!isStyleSideEffect || !shouldRegroupSideEffectStyleNodes),
+        dependencies: options.useExperimentalDependencyDetection
+          ? []
+          : computeDependencies(node),
         isEslintDisabled: isNodeEslintDisabled(node, eslintDisabledLines),
         dependencyNames: computeDependencyNames({ sourceCode, node }),
         specifierName: computeSpecifierName({ sourceCode, node }),
         isTypeImport: modifiers.includes('type'),
-        dependencies: computeDependencies(node),
         addSafetySemicolonWhenInline: true,
         group,
         size,
@@ -280,6 +286,8 @@ const sortImports = createEslintRule({
             enum: ['node', 'bun'],
             type: 'string',
           },
+          useExperimentalDependencyDetection:
+            useExperimentalDependencyDetectionJsonSchema,
           partitionByComment: partitionByCommentJsonSchema,
           partitionByNewLine: partitionByNewLineJsonSchema,
           internalPattern: buildRegexJsonSchema(),
@@ -311,8 +319,7 @@ const sortImports = createEslintRule({
 })
 function sortImportNodes({ sortingNodesWithoutPartitionId, options, context }) {
   let { sourceCode } = context
-  let optionsByGroupIndexComputer =
-    buildDefaultOptionsByGroupIndexComputer(options)
+  let optionsByGroupIndexComputer = buildOptionsByGroupIndexComputer(options)
   let contentSeparatedSortingNodeGroups = [[[]]]
   for (let sortingNodeWithoutPartitionId of sortingNodesWithoutPartitionId) {
     let lastGroupWithNoContentBetween = contentSeparatedSortingNodeGroups.at(-1)
@@ -341,8 +348,19 @@ function sortImportNodes({ sortingNodesWithoutPartitionId, options, context }) {
       partitionId: lastGroupWithNoContentBetween.length,
     })
   }
-  for (let sortingNodeGroups of contentSeparatedSortingNodeGroups) {
-    let nodes = sortingNodeGroups.flat()
+  for (let contentSeparatedSortingNodeGroup of contentSeparatedSortingNodeGroups) {
+    let sortingNodeGroups = [...contentSeparatedSortingNodeGroup]
+    if (options.useExperimentalDependencyDetection) {
+      let dependenciesBySortingNode = computeDependenciesBySortingNode({
+        sortingNodes: sortingNodeGroups.flat(),
+        sourceCode,
+      })
+      sortingNodeGroups = populateSortingNodeGroupsWithDependencies({
+        dependenciesBySortingNode,
+        sortingNodeGroups,
+      })
+    }
+    let sortingNodes = sortingNodeGroups.flat()
     reportAllErrors({
       availableMessageIds: {
         unexpectedDependencyOrder: DEPENDENCY_ORDER_ERROR_ID,
@@ -354,9 +372,9 @@ function sortImportNodes({ sortingNodesWithoutPartitionId, options, context }) {
       },
       sortNodesExcludingEslintDisabled:
         createSortNodesExcludingEslintDisabled(sortingNodeGroups),
+      nodes: sortingNodes,
       options,
       context,
-      nodes,
     })
   }
   function createSortNodesExcludingEslintDisabled(nodeGroups) {

package/dist/rules/sort-jsx-props.js

@@ -16,9 +16,9 @@ import {
   allModifiers,
 } from './sort-jsx-props/types.js'
 import { validateNewlinesAndPartitionConfiguration } from '../utils/validate-newlines-and-partition-configuration.js'
-import { buildDefaultOptionsByGroupIndexComputer } from '../utils/build-default-options-by-group-index-computer.js'
 import { defaultComparatorByOptionsComputer } from '../utils/compare/default-comparator-by-options-computer.js'
 import { partitionByNewLineJsonSchema } from '../utils/json-schemas/common-partition-json-schemas.js'
+import { buildOptionsByGroupIndexComputer } from '../utils/build-options-by-group-index-computer.js'
 import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
 import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration.js'
 import { filterOptionsByAllNamesMatch } from '../utils/filter-options-by-all-names-match.js'
@@ -83,6 +83,8 @@ const sortJsxProps = createEslintRule({
         ruleName: id,
         sourceCode,
       })
+      let optionsByGroupIndexComputer =
+        buildOptionsByGroupIndexComputer(options)
       let formattedMembers = node.openingElement.attributes.reduce(
         (accumulator, attribute) => {
           if (attribute.type === AST_NODE_TYPES.JSXSpreadAttribute) {
@@ -154,9 +156,8 @@ const sortJsxProps = createEslintRule({
         let createSortNodesExcludingEslintDisabled = function (nodes) {
           return function (ignoreEslintDisabledNodes) {
             return sortNodesByGroups({
-              optionsByGroupIndexComputer:
-                buildDefaultOptionsByGroupIndexComputer(options),
               comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
+              optionsByGroupIndexComputer,
               ignoreEslintDisabledNodes,
               groups: options.groups,
               nodes,

package/dist/rules/sort-maps.js

@@ -13,8 +13,8 @@ import {
   buildUseConfigurationIfJsonSchema,
   buildCommonJsonSchemas,
 } from '../utils/json-schemas/common-json-schemas.js'
-import { buildDefaultOptionsByGroupIndexComputer } from '../utils/build-default-options-by-group-index-computer.js'
 import { defaultComparatorByOptionsComputer } from '../utils/compare/default-comparator-by-options-computer.js'
+import { buildOptionsByGroupIndexComputer } from '../utils/build-options-by-group-index-computer.js'
 import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
 import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration.js'
 import { filterOptionsByAllNamesMatch } from '../utils/filter-options-by-all-names-match.js'
@@ -88,6 +88,8 @@ const sortMaps = createEslintRule({
         ruleName: id,
         sourceCode,
       })
+      let optionsByGroupIndexComputer =
+        buildOptionsByGroupIndexComputer(options)
       let parts = elements.reduce(
         (accumulator, element) => {
           if (
@@ -150,9 +152,8 @@ const sortMaps = createEslintRule({
           let createSortNodesExcludingEslintDisabled = function (sortingNodes) {
             return function (ignoreEslintDisabledNodes) {
               return sortNodesByGroups({
-                optionsByGroupIndexComputer:
-                  buildDefaultOptionsByGroupIndexComputer(options),
                 comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
+                optionsByGroupIndexComputer,
                 ignoreEslintDisabledNodes,
                 groups: options.groups,
                 nodes: sortingNodes,

package/dist/rules/sort-modules/build-comparator-by-options-computer.d.ts

@@ -1,12 +1,17 @@
+import { TSESLint } from '@typescript-eslint/utils'
 import { ComparatorByOptionsComputer } from '../../utils/compare/default-comparator-by-options-computer.js'
-import { SortModulesSortingNode, SortModulesOptions } from './types.js'
+import { SortModulesSortingNode, Options } from './types.js'
 export declare function buildComparatorByOptionsComputer({
+  useExperimentalDependencyDetection,
   ignoreEslintDisabledNodes,
   sortingNodes,
+  sourceCode,
 }: {
+  useExperimentalDependencyDetection: boolean
   sortingNodes: SortModulesSortingNode[]
   ignoreEslintDisabledNodes: boolean
+  sourceCode: TSESLint.SourceCode
 }): ComparatorByOptionsComputer<
-  Required<SortModulesOptions[number]>,
+  Required<Options[number]>,
   SortModulesSortingNode
 >