eslint-plugin-perfectionist 5.10.0 → 5.11.0

package/dist/package.json.js

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

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

@@ -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-classes/compute-dependencies-by-sorting-node.js

@@ -1,7 +1,6 @@
 import { UnreachableCaseError } from '../../utils/unreachable-case-error.js'
-import { matches } from '../../utils/matches.js'
 import { computeDependenciesBySortingNode as computeDependenciesBySortingNode$1 } from '../../utils/compute-dependencies-by-sorting-node.js'
-import { computeParentNodesWithTypes } from '../../utils/compute-parent-nodes-with-types.js'
+import { isNodeInsideDeferredFunction } from '../../utils/is-node-inside-deferred-function.js'
 import { computeIdentifierNameDetails } from './compute-identifier-name-details.js'
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils'
 function computeDependenciesBySortingNode({
@@ -10,11 +9,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 =>
@@ -43,7 +43,14 @@ function computeIdentifierOrThisExpressionDependency({
   classElement,
   node,
 }) {
-  if (shouldIgnoreCallbackDependency()) {
+  if (
+    classElement.type !== AST_NODE_TYPES.StaticBlock &&
+    isNodeInsideDeferredFunction({
+      ignoreCallbackDependenciesPatterns,
+      maxParent: classElement,
+      node,
+    })
+  ) {
     return null
   }
   let { parent } = node
@@ -72,24 +79,6 @@ function computeIdentifierOrThisExpressionDependency({
         return null
     }
   }
-  function shouldIgnoreCallbackDependency() {
-    let [firstCallExpressionParent] = computeParentNodesWithTypes({
-      allowedTypes: [AST_NODE_TYPES.CallExpression],
-      maxParent: classElement,
-      consecutiveOnly: false,
-      node,
-    })
-    if (!firstCallExpressionParent) {
-      return false
-    }
-    if (!('name' in firstCallExpressionParent.callee)) {
-      return false
-    }
-    return matches(
-      firstCallExpressionParent.callee.name,
-      ignoreCallbackDependenciesPatterns,
-    )
-  }
 }
 function computeThisExpressionDependenciesBySortingNode({
   ignoreCallbackDependenciesPatterns,
@@ -146,27 +135,6 @@ function buildAdditionalIdentifierDependenciesComputer({
     return dependency ? [dependency] : []
   }
 }
-function shouldIgnoreDependencyComputation(node) {
-  switch (node.type) {
-    case AST_NODE_TYPES.TSAbstractPropertyDefinition:
-    case AST_NODE_TYPES.TSAbstractMethodDefinition:
-    case AST_NODE_TYPES.StaticBlock:
-      return false
-    case AST_NODE_TYPES.TSAbstractAccessorProperty:
-    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)
-  }
-}
 function computeThisExpressionsInsideClassElement({
   classElement,
   sourceCode,
@@ -183,4 +151,21 @@ function computeThisExpressionsInsideClassElement({
     return token.type === AST_TOKEN_TYPES.Keyword && token.value === 'this'
   }
 }
+function shouldIgnoreDependencyComputation(node) {
+  switch (node.type) {
+    case AST_NODE_TYPES.TSAbstractPropertyDefinition:
+    case AST_NODE_TYPES.TSAbstractAccessorProperty:
+    case AST_NODE_TYPES.TSAbstractMethodDefinition:
+    case AST_NODE_TYPES.PropertyDefinition:
+    case AST_NODE_TYPES.AccessorProperty:
+    case AST_NODE_TYPES.StaticBlock:
+      return false
+    case AST_NODE_TYPES.MethodDefinition:
+    case AST_NODE_TYPES.TSIndexSignature:
+      return true
+    /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+    default:
+      throw new UnreachableCaseError(node)
+  }
+}
 export { computeDependenciesBySortingNode }

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-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/sort-class.js

@@ -94,15 +94,12 @@ function sortClass({ matchedAstSelectors, context, node }) {
     return
   }
   let settings = getSettings(context.settings)
-  let options = complete(
-    computeMatchedContextOptions({
-      matchedAstSelectors,
-      classElements,
-      context,
-    }),
-    settings,
-    defaultOptions,
-  )
+  let matchedContextOptions = computeMatchedContextOptions({
+    matchedAstSelectors,
+    classElements,
+    context,
+  })
+  let options = complete(matchedContextOptions, settings, defaultOptions)
   validateCustomSortConfig(options)
   validateGroupsConfig({
     modifiers: allModifiers,
@@ -235,6 +232,11 @@ function sortClass({ matchedAstSelectors, context, node }) {
         default:
           throw new UnreachableCaseError(member)
       }
+      let predefinedGroups = generatePredefinedGroups({
+        cache: cachedGroupsByModifiersAndSelectors,
+        selectors,
+        modifiers,
+      })
       let group = computeGroup({
         customGroupMatcher: customGroup =>
           doesCustomGroupMatch({
@@ -245,11 +247,7 @@ function sortClass({ matchedAstSelectors, context, node }) {
             modifiers,
             selectors,
           }),
-        predefinedGroups: generatePredefinedGroups({
-          cache: cachedGroupsByModifiersAndSelectors,
-          selectors,
-          modifiers,
-        }),
+        predefinedGroups,
         options,
       })
       let sortingNode = {
@@ -288,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,
     })
   }
@@ -315,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

@@ -50,7 +50,7 @@ export type Options = Partial<
      */
     ignoreCallbackDependenciesPatterns: RegexOption
     /**
-     * Enables experimental dependency detection.
+     * @deprecated Enables experimental dependency detection.
      */
     useExperimentalDependencyDetection: boolean
   } & AllCommonOptions<

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

@@ -31,9 +31,6 @@ function computeDependencies(expression, enumName) {
         break
       case AST_NODE_TYPES.Identifier:
         dependencies.push(node.name)
-        break
-      default:
-        break
     }
     if ('alternate' in node && node.alternate) {
       stack.push(node.alternate)

package/dist/rules/sort-enums/sort-enum.js

@@ -54,15 +54,12 @@ function sortEnum({ matchedAstSelectors, context, node }) {
     return
   }
   let settings = getSettings(context.settings)
-  let options = complete(
-    computeMatchedContextOptions({
-      enumMembers: members,
-      matchedAstSelectors,
-      context,
-    }),
-    settings,
-    defaultOptions,
-  )
+  let matchedContextOptions = computeMatchedContextOptions({
+    enumMembers: members,
+    matchedAstSelectors,
+    context,
+  })
+  let options = complete(matchedContextOptions, settings, defaultOptions)
   validateCustomSortConfig(options)
   validateGroupsConfig({
     selectors: [],
@@ -131,12 +128,13 @@ function sortEnum({ matchedAstSelectors, context, node }) {
     [[]],
   )
   if (options.useExperimentalDependencyDetection) {
+    let dependenciesBySortingNode = computeDependenciesBySortingNode({
+      sortingNodes: sortingNodeGroups.flat(),
+      enumName: node.id.name,
+      sourceCode,
+    })
     sortingNodeGroups = populateSortingNodeGroupsWithDependencies({
-      dependenciesBySortingNode: computeDependenciesBySortingNode({
-        sortingNodes: sortingNodeGroups.flat(),
-        enumName: node.id.name,
-        sourceCode,
-      }),
+      dependenciesBySortingNode,
       sortingNodeGroups,
     })
   }
@@ -158,19 +156,19 @@ function sortEnum({ matchedAstSelectors, context, node }) {
     context,
   })
   function sortNodesExcludingEslintDisabled(ignoreEslintDisabledNodes) {
-    return sortNodesByDependencies(
-      sortingNodeGroups.flatMap(sortingNodeGroup =>
-        sortNodesByGroups({
-          comparatorByOptionsComputer:
-            buildComparatorByOptionsComputer(isNumericEnum),
-          optionsByGroupIndexComputer,
-          ignoreEslintDisabledNodes,
-          nodes: sortingNodeGroup,
-          groups: options.groups,
-        }),
-      ),
-      { ignoreEslintDisabledNodes },
+    let nodesSortedByGroups = sortingNodeGroups.flatMap(sortingNodeGroup =>
+      sortNodesByGroups({
+        comparatorByOptionsComputer:
+          buildComparatorByOptionsComputer(isNumericEnum),
+        optionsByGroupIndexComputer,
+        ignoreEslintDisabledNodes,
+        nodes: sortingNodeGroup,
+        groups: options.groups,
+      }),
     )
+    return sortNodesByDependencies(nodesSortedByGroups, {
+      ignoreEslintDisabledNodes,
+    })
   }
 }
 export { defaultOptions, sortEnum }

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

@@ -47,7 +47,7 @@ export type Options = Partial<
      */
     sortByValue: 'ifNumericEnum' | 'always' | 'never'
     /**
-     * Enables experimental dependency detection.
+     * @deprecated Enables experimental dependency detection.
      */
     useExperimentalDependencyDetection: boolean
   } & AllCommonOptions<

package/dist/rules/sort-exports.js

@@ -88,6 +88,11 @@ var sort_exports_default = createEslintRule({
         computeLineCountModifier(node),
       ]
       let name = node.source.value
+      let predefinedGroups = generatePredefinedGroups({
+        cache: cachedGroupsByModifiersAndSelectors,
+        selectors: [selector],
+        modifiers,
+      })
       let group = computeGroup({
         customGroupMatcher: customGroup =>
           doesCustomGroupMatch({
@@ -96,11 +101,7 @@ var sort_exports_default = createEslintRule({
             customGroup,
             modifiers,
           }),
-        predefinedGroups: generatePredefinedGroups({
-          cache: cachedGroupsByModifiersAndSelectors,
-          selectors: [selector],
-          modifiers,
-        }),
+        predefinedGroups,
         options,
       })
       let sortingNode = {

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

@@ -48,15 +48,12 @@ function sortHeritageClause({ matchedAstSelectors, context, node }) {
     return
   }
   let settings = getSettings(context.settings)
-  let options = complete(
-    computeMatchedContextOptions({
-      matchedAstSelectors,
-      heritageClauses,
-      context,
-    }),
-    settings,
-    defaultOptions,
-  )
+  let matchedContextOptions = computeMatchedContextOptions({
+    matchedAstSelectors,
+    heritageClauses,
+    context,
+  })
+  let options = complete(matchedContextOptions, settings, defaultOptions)
   validateCustomSortConfig(options)
   validateGroupsConfig({
     modifiers: [],

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

@@ -29,15 +29,12 @@ function sortImportOrExportAttributes({
   }
   let { sourceCode, id } = context
   let settings = getSettings(context.settings)
-  let options = complete(
-    computeMatchedContextOptions({
-      matchedAstSelectors,
-      attributes,
-      context,
-    }),
-    settings,
-    defaultOptions,
-  )
+  let matchedContextOptions = computeMatchedContextOptions({
+    matchedAstSelectors,
+    attributes,
+    context,
+  })
+  let options = complete(matchedContextOptions, settings, defaultOptions)
   validateCustomSortConfig(options)
   validateGroupsConfig({
     selectors: [],

package/dist/rules/sort-imports/compute-common-selectors.d.ts

@@ -1,4 +1,4 @@
-import { ReadClosestTsConfigByPathValue } from './read-closest-ts-config-by-path.js'
+import { ReadClosestTsConfigByPathValue } from '../../utils/tsconfig/read-closest-ts-config-by-path.js'
 import { RegexOption } from '../../types/common-options.js'
 import { Selector } from './types.js'
 /**

package/dist/rules/sort-imports/compute-common-selectors.js

@@ -1,5 +1,5 @@
 import { matches } from '../../utils/matches.js'
-import { getTypescriptImport } from './get-typescript-import.js'
+import { getTypescriptImport } from '../../utils/tsconfig/get-typescript-import.js'
 import { matchesTsconfigPaths } from './matches-tsconfig-paths.js'
 import { builtinModules } from 'node:module'
 /**
@@ -135,7 +135,7 @@ function isCoreModule(value, environment) {
   function clean(string_) {
     return string_.replace(/^(?:node:){1,2}/u, '')
   }
-  let [basePath] = value.split('/')
+  let [basePath] = value.split('/', 1)
   let cleanValue = clean(value)
   let cleanBase = clean(basePath)
   if (nodeBuiltinModules.has(cleanValue) || nodeBuiltinModules.has(cleanBase)) {

package/dist/rules/sort-imports/matches-tsconfig-paths.d.ts

@@ -1,4 +1,4 @@
-import { ReadClosestTsConfigByPathValue } from './read-closest-ts-config-by-path.js'
+import { ReadClosestTsConfigByPathValue } from '../../utils/tsconfig/read-closest-ts-config-by-path.js'
 /**
  * Checks if an import matches any of the path mappings in tsconfig.json.
  *

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

@@ -3,6 +3,7 @@ import { TSESTree } from '@typescript-eslint/types'
 import { SortingNodeWithDependencies } from '../../utils/sort-nodes-by-dependencies.js'
 import { RegexOption, TypeOption } from '../../types/common-options.js'
 import { AllCommonOptions } from '../../types/all-common-options.js'
+import { TsConfigOption } from '../../types/ts-config-option.js'
 /**
  * Configuration options for the sort-imports rule.
  *
@@ -12,22 +13,7 @@ import { AllCommonOptions } from '../../types/all-common-options.js'
 export type Options = Partial<
   {
     /**
-     * TypeScript configuration for resolving module paths. Enables path alias
-     * resolution based on tsconfig.json paths configuration.
-     */
-    tsconfig: {
-      /**
-       * Optional filename of the TypeScript config file. `@default`
-       * tsconfig.json'.
-       */
-      filename?: string
-      /**
-       * Root directory where to search for the TypeScript config file.
-       */
-      rootDir: string
-    }
-    /**
-     * Enables experimental dependency detection.
+     * @deprecated Enables experimental dependency detection.
      */
     useExperimentalDependencyDetection: boolean
     /**
@@ -42,6 +28,11 @@ export type Options = Partial<
      * @default 'node'
      */
     environment: 'node' | 'bun'
+    /**
+     * TypeScript configuration for resolving module paths. Enables path alias
+     * resolution based on tsconfig.json paths configuration.
+     */
+    tsconfig: TsConfigOption
     /**
      * Controls whether side-effect imports should be sorted. When false,
      * side-effect imports remain in their original positions.