eslint-plugin-perfectionist 5.3.1 → 5.4.0

package/dist/package.json.js

@@ -1,3 +1,3 @@
 const name = 'eslint-plugin-perfectionist'
-const version = '5.3.1'
+const version = '5.4.0'
 export { name, version }

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

@@ -14,12 +14,12 @@ import {
   buildCommonJsonSchemas,
 } from '../utils/json-schemas/common-json-schemas.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 {
   additionalCustomGroupMatchOptionsJsonSchema,
   allSelectors,
 } from './sort-array-includes/types.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'
@@ -145,6 +145,7 @@ function sortArray({ availableMessageIds, elements, context }) {
     ruleName: id,
     sourceCode,
   })
+  let optionsByGroupIndexComputer = buildOptionsByGroupIndexComputer(options)
   let formattedMembers = elements.reduce(
     (accumulator, element) => {
       if (element === null) {
@@ -198,9 +199,8 @@ function sortArray({ availableMessageIds, elements, context }) {
   function sortNodesExcludingEslintDisabled(ignoreEslintDisabledNodes) {
     return formattedMembers.flatMap(nodes2 =>
       sortNodesByGroups({
-        optionsByGroupIndexComputer:
-          buildDefaultOptionsByGroupIndexComputer(options),
         comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
+        optionsByGroupIndexComputer,
         ignoreEslintDisabledNodes,
         groups: options.groups,
         nodes: nodes2,

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

@@ -17,14 +17,13 @@ function computeDependencies({
         traverseNode(nodeValue.alternate)
         break
       case AST_NODE_TYPES.MemberExpression:
-        dependencies = [
-          ...dependencies,
+        dependencies.push(
           ...computeMemberExpressionDependencies({
             memberExpression: nodeValue,
             isMemberStatic,
             className,
           }),
-        ]
+        )
         break
       case AST_NODE_TYPES.CallExpression:
         if (!('name' in nodeValue.callee)) {

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

@@ -0,0 +1,13 @@
+import { TSESTree } from '@typescript-eslint/utils'
+import { OverloadSignatureGroup } from '../../utils/overload-signature/overload-signature-group.js'
+type Method = TSESTree.TSAbstractMethodDefinition | TSESTree.MethodDefinition
+/**
+ * Returns a list of groups of overload signatures.
+ *
+ * @param classElements - The class elements to process.
+ * @returns A list of overload signature groups.
+ */
+export declare function computeOverloadSignatureGroups(
+  classElements: TSESTree.ClassElement[],
+): OverloadSignatureGroup<Method>[]
+export {}

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

@@ -0,0 +1,58 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import { OverloadSignatureGroup } from '../../utils/overload-signature/overload-signature-group.js'
+import { UnreachableCaseError } from '../../utils/unreachable-case-error.js'
+import { isSortable } from '../../utils/is-sortable.js'
+function computeOverloadSignatureGroups(classElements) {
+  let methods = classElements
+    .filter(
+      classElement =>
+        classElement.type === AST_NODE_TYPES.MethodDefinition ||
+        classElement.type === AST_NODE_TYPES.TSAbstractMethodDefinition,
+    )
+    .filter(classElement => classElement.kind === 'method')
+  let staticOverloadSignaturesByName = /* @__PURE__ */ new Map()
+  let overloadSignaturesByName = /* @__PURE__ */ new Map()
+  for (let method of methods) {
+    if (method.key.type !== AST_NODE_TYPES.Identifier) {
+      continue
+    }
+    let { name } = method.key
+    let mapToUse = method.static
+      ? staticOverloadSignaturesByName
+      : overloadSignaturesByName
+    let overloadSignaturesArray = mapToUse.get(name)
+    if (!overloadSignaturesArray) {
+      overloadSignaturesArray = []
+      mapToUse.set(name, overloadSignaturesArray)
+    }
+    overloadSignaturesArray.push(method)
+  }
+  return [
+    ...overloadSignaturesByName.values(),
+    ...staticOverloadSignaturesByName.values(),
+  ]
+    .filter(isSortable)
+    .map(buildOverloadSignatureGroup)
+}
+function buildOverloadSignatureGroup(methods) {
+  let implementation = methods.find(isMethodImplementation) ?? methods.at(-1)
+  let overloadSignatures = methods.filter(
+    method => !isMethodImplementation(method),
+  )
+  return new OverloadSignatureGroup({
+    overloadSignatures,
+    implementation,
+  })
+  function isMethodImplementation(method) {
+    switch (method.value.type) {
+      case AST_NODE_TYPES.TSEmptyBodyFunctionExpression:
+        return false
+      case AST_NODE_TYPES.FunctionExpression:
+        return true
+      /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+      default:
+        throw new UnreachableCaseError(method.value)
+    }
+  }
+}
+export { computeOverloadSignatureGroups }

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

@@ -1,4 +1,6 @@
 import { JSONSchema4 } from '@typescript-eslint/utils/json-schema'
+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'
 /**
@@ -7,7 +9,7 @@ import { AllCommonOptions } from '../../types/all-common-options.js'
  * This rule enforces consistent ordering of class members (properties, methods,
  * constructors, etc.) to improve code readability and maintainability.
  */
-export type SortClassesOptions = [
+export type Options = [
   Partial<
     {
       /**
@@ -23,6 +25,12 @@ export type SortClassesOptions = [
     >
   >,
 ]
+export interface SortClassesSortingNode extends SortingNodeWithDependencies<TSESTree.ClassElement> {
+  overloadSignatureImplementation:
+    | TSESTree.TSAbstractMethodDefinition
+    | TSESTree.MethodDefinition
+    | null
+}
 /**
  * Union type of all available class member selectors. Used to identify and
  * categorize different types of class members.

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

@@ -1,4 +1,4 @@
-import { SortClassesOptions } from './sort-classes/types.js'
+import { Options } from './sort-classes/types.js'
 declare const ORDER_ERROR_ID = 'unexpectedClassesOrder'
 declare const GROUP_ORDER_ERROR_ID = 'unexpectedClassesGroupOrder'
 declare const EXTRA_SPACING_ERROR_ID = 'extraSpacingBetweenClassMembers'
@@ -12,7 +12,7 @@ type MessageId =
   | typeof ORDER_ERROR_ID
 declare const _default: import('@typescript-eslint/utils/ts-eslint').RuleModule<
   MessageId,
-  SortClassesOptions,
+  Options,
   import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
   import('@typescript-eslint/utils/ts-eslint').RuleListener
 > & {

package/dist/rules/sort-classes.js

@@ -6,6 +6,8 @@ import {
   MISSED_SPACING_ERROR,
   DEPENDENCY_ORDER_ERROR,
 } from '../utils/report-errors.js'
+import { buildOverloadSignatureNewlinesBetweenValueGetter } from '../utils/overload-signature/build-overload-signature-newlines-between-value-getter.js'
+import { populateSortingNodeGroupsWithOverloadSignature } from '../utils/overload-signature/populate-sorting-node-groups-with-overload-signature.js'
 import {
   partitionByNewLineJsonSchema,
   partitionByCommentJsonSchema,
@@ -16,19 +18,19 @@ import {
   allModifiers,
 } from './sort-classes/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 {
   buildRegexJsonSchema,
   buildCommonJsonSchemas,
 } from '../utils/json-schemas/common-json-schemas.js'
 import { defaultComparatorByOptionsComputer } from '../utils/compare/default-comparator-by-options-computer.js'
 import { computeIndexSignatureDetails } from './sort-classes/node-info/compute-index-signature-details.js'
+import { buildOptionsByGroupIndexComputer } from '../utils/build-options-by-group-index-computer.js'
 import { computeStaticBlockDetails } from './sort-classes/node-info/compute-static-block-details.js'
+import { computeOverloadSignatureGroups } from './sort-classes/compute-overload-signature-groups.js'
 import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
 import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration.js'
 import { computePropertyDetails } from './sort-classes/node-info/compute-property-details.js'
 import { computeAccessorDetails } from './sort-classes/node-info/compute-accessor-details.js'
-import { getOverloadSignatureGroups } from './sort-classes/get-overload-signature-groups.js'
 import { computeMethodDetails } from './sort-classes/node-info/compute-method-details.js'
 import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.js'
 import { generatePredefinedGroups } from '../utils/generate-predefined-groups.js'
@@ -114,9 +116,12 @@ const sortClasses = createEslintRule({
         ruleName: id,
         sourceCode,
       })
+      let optionsByGroupIndexComputer =
+        buildOptionsByGroupIndexComputer(options)
+      let overloadSignatureNewlinesBetweenValueGetter =
+        buildOverloadSignatureNewlinesBetweenValueGetter()
       let className = node.parent.id?.name
-      let overloadSignatureGroups = getOverloadSignatureGroups(node.body)
-      let formattedNodes = node.body.reduce(
+      let sortingNodeGroupsWithoutOverloadSignature = node.body.reduce(
         (accumulator, member) => {
           let dependencies = []
           let isDecorated = false
@@ -216,21 +221,9 @@ const sortClasses = createEslintRule({
             predefinedGroups,
             options,
           })
-          let overloadSignatureGroupMemberIndex =
-            overloadSignatureGroups.findIndex(overloadSignatures =>
-              overloadSignatures.includes(member),
-            )
-          let overloadSignatureGroupMember =
-            overloadSignatureGroups[overloadSignatureGroupMemberIndex]?.at(-1)
           let sortingNode = {
-            overloadSignaturesGroupId:
-              overloadSignatureGroupMemberIndex === -1
-                ? null
-                : overloadSignatureGroupMemberIndex,
-            size: overloadSignatureGroupMember
-              ? rangeToDiff(overloadSignatureGroupMember, sourceCode)
-              : rangeToDiff(member, sourceCode),
             isEslintDisabled: isNodeEslintDisabled(member, eslintDisabledLines),
+            size: rangeToDiff(member, sourceCode),
             addSafetySemicolonWhenInline,
             dependencyNames,
             node: member,
@@ -257,51 +250,42 @@ const sortClasses = createEslintRule({
         },
         [[]],
       )
+      let sortingNodeGroups = populateSortingNodeGroupsWithOverloadSignature({
+        overloadSignatureGroups: computeOverloadSignatureGroups(node.body),
+        sortingNodeGroups: sortingNodeGroupsWithoutOverloadSignature,
+      })
+      let sortingNodes = sortingNodeGroups.flat()
+      reportAllErrors({
+        availableMessageIds: {
+          missedSpacingBetweenMembers: MISSED_SPACING_ERROR_ID,
+          unexpectedDependencyOrder: DEPENDENCY_ORDER_ERROR_ID,
+          extraSpacingBetweenMembers: EXTRA_SPACING_ERROR_ID,
+          unexpectedGroupOrder: GROUP_ORDER_ERROR_ID,
+          unexpectedOrder: ORDER_ERROR_ID,
+        },
+        newlinesBetweenValueGetter: overloadSignatureNewlinesBetweenValueGetter,
+        sortNodesExcludingEslintDisabled,
+        nodes: sortingNodes,
+        options,
+        context,
+      })
       function sortNodesExcludingEslintDisabled(ignoreEslintDisabledNodes) {
-        let nodesSortedByGroups = formattedNodes.flatMap(nodes2 =>
+        let nodesSortedByGroups = sortingNodeGroups.flatMap(sortingNodeGroup =>
           sortNodesByGroups({
             isNodeIgnored: sortingNode =>
               getGroupIndex(options.groups, sortingNode) ===
               options.groups.length,
-            optionsByGroupIndexComputer:
-              buildDefaultOptionsByGroupIndexComputer(options),
             comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
+            optionsByGroupIndexComputer,
             ignoreEslintDisabledNodes,
+            nodes: sortingNodeGroup,
             groups: options.groups,
-            nodes: nodes2,
           }),
         )
         return sortNodesByDependencies(nodesSortedByGroups, {
           ignoreEslintDisabledNodes,
         })
       }
-      let nodes = formattedNodes.flat()
-      reportAllErrors({
-        newlinesBetweenValueGetter: ({
-          computedNewlinesBetween,
-          right,
-          left,
-        }) => {
-          if (
-            left.overloadSignaturesGroupId !== null &&
-            left.overloadSignaturesGroupId === right.overloadSignaturesGroupId
-          ) {
-            return 0
-          }
-          return computedNewlinesBetween
-        },
-        availableMessageIds: {
-          missedSpacingBetweenMembers: MISSED_SPACING_ERROR_ID,
-          unexpectedDependencyOrder: DEPENDENCY_ORDER_ERROR_ID,
-          extraSpacingBetweenMembers: EXTRA_SPACING_ERROR_ID,
-          unexpectedGroupOrder: GROUP_ORDER_ERROR_ID,
-          unexpectedOrder: ORDER_ERROR_ID,
-        },
-        sortNodesExcludingEslintDisabled,
-        options,
-        context,
-        nodes,
-      })
     },
   }),
   meta: {

package/dist/rules/sort-decorators.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'
@@ -178,6 +178,7 @@ function sortDecorators$1(context, options, decorators) {
     ruleName: id,
     sourceCode,
   })
+  let optionsByGroupIndexComputer = buildOptionsByGroupIndexComputer(options)
   let formattedMembers = decorators.reduce(
     (accumulator, decorator) => {
       let name = getDecoratorName({
@@ -224,9 +225,8 @@ function sortDecorators$1(context, options, decorators) {
   function sortNodesExcludingEslintDisabled(ignoreEslintDisabledNodes) {
     return formattedMembers.flatMap(nodes2 =>
       sortNodesByGroups({
-        optionsByGroupIndexComputer:
-          buildDefaultOptionsByGroupIndexComputer(options),
         comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
+        optionsByGroupIndexComputer,
         ignoreEslintDisabledNodes,
         groups: options.groups,
         nodes: nodes2,

package/dist/rules/sort-enums/compute-dependencies-by-sorting-node.d.ts

@@ -0,0 +1,13 @@
+import { TSESLint } from '@typescript-eslint/utils'
+import { SortEnumsSortingNode } from './types.js'
+type SortingNodeWithoutDependencies = Omit<SortEnumsSortingNode, 'dependencies'>
+export declare function computeDependenciesBySortingNode({
+  sortingNodes,
+  sourceCode,
+  enumName,
+}: {
+  sortingNodes: SortingNodeWithoutDependencies[]
+  sourceCode: TSESLint.SourceCode
+  enumName: string
+}): Map<SortingNodeWithoutDependencies, SortingNodeWithoutDependencies[]>
+export {}

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

@@ -0,0 +1,51 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import { computeDependenciesBySortingNode as computeDependenciesBySortingNode$1 } from '../../utils/compute-dependencies-by-sorting-node.js'
+import { doesSortingNodeHaveOneOfDependencyNames } from '../../utils/does-sorting-node-have-one-of-dependency-names.js'
+import { computeParentNodesWithTypes } from '../../utils/compute-parent-nodes-with-types.js'
+function computeDependenciesBySortingNode({
+  sortingNodes,
+  sourceCode,
+  enumName,
+}) {
+  return computeDependenciesBySortingNode$1({
+    additionalIdentifierDependenciesComputer:
+      buildAdditionalIdentifierDependenciesComputer({
+        sortingNodes,
+        enumName,
+      }),
+    sortingNodes,
+    sourceCode,
+  })
+}
+function buildAdditionalIdentifierDependenciesComputer({
+  sortingNodes,
+  enumName,
+}) {
+  return ({ referencingSortingNode, identifier }) => {
+    if (identifier.name !== enumName) {
+      return []
+    }
+    let relatedIdentifiers = computeMemberExpressionIdentifiers(
+      identifier,
+      referencingSortingNode,
+    )
+    return sortingNodes.filter(sortingNode =>
+      doesSortingNodeHaveOneOfDependencyNames(sortingNode, relatedIdentifiers),
+    )
+  }
+}
+function computeMemberExpressionIdentifiers(
+  identifier,
+  referencingSortingNode,
+) {
+  return computeParentNodesWithTypes({
+    allowedTypes: [AST_NODE_TYPES.MemberExpression],
+    maxParent: referencingSortingNode.node,
+    consecutiveOnly: true,
+    node: identifier,
+  })
+    .map(node => node.property)
+    .filter(property => property.type === AST_NODE_TYPES.Identifier)
+    .map(property => property.name)
+}
+export { computeDependenciesBySortingNode }

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

@@ -0,0 +1,14 @@
+import { TSESTree } from '@typescript-eslint/types'
+/**
+ * Extract dependencies from an enum.
+ *
+ * @deprecated - To remove when experimental dependency detection is the only
+ *   option.
+ * @param expression - The enum or class declaration node.
+ * @param enumName - The name of the enum being processed.
+ * @returns The list of dependencies.
+ */
+export declare function computeDependencies(
+  expression: TSESTree.Expression,
+  enumName: string,
+): string[]

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

@@ -0,0 +1,73 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+function computeDependencies(expression, enumName) {
+  let dependencies = []
+  let stack = [expression]
+  while (stack.length > 0) {
+    let node = stack.pop()
+    switch (node.type) {
+      case AST_NODE_TYPES.MemberExpression:
+        if (
+          node.object.type === AST_NODE_TYPES.Identifier &&
+          node.object.name === enumName &&
+          node.property.type === AST_NODE_TYPES.Identifier
+        ) {
+          dependencies.push(node.property.name)
+        }
+        break
+      case AST_NODE_TYPES.Identifier:
+        dependencies.push(node.name)
+        break
+    }
+    if ('alternate' in node && node.alternate) {
+      stack.push(node.alternate)
+    }
+    if ('argument' in node && node.argument) {
+      stack.push(node.argument)
+    }
+    if ('arguments' in node) {
+      stack.push(...node.arguments)
+    }
+    if ('consequent' in node) {
+      if (Array.isArray(node.consequent)) {
+        stack.push(...node.consequent)
+      } else {
+        stack.push(node.consequent)
+      }
+    }
+    if ('elements' in node) {
+      let elements = node.elements.filter(currentNode => currentNode !== null)
+      stack.push(...elements)
+    }
+    if ('expressions' in node) {
+      stack.push(...node.expressions)
+    }
+    if ('key' in node) {
+      stack.push(node.key)
+    }
+    if ('left' in node) {
+      stack.push(node.left)
+    }
+    if ('object' in node) {
+      stack.push(node.object)
+    }
+    if ('properties' in node) {
+      stack.push(...node.properties)
+    }
+    if ('right' in node) {
+      stack.push(node.right)
+    }
+    if ('test' in node && node.test) {
+      stack.push(node.test)
+    }
+    if (
+      'value' in node &&
+      node.value &&
+      typeof node.value === 'object' &&
+      'type' in node.value
+    ) {
+      stack.push(node.value)
+    }
+  }
+  return dependencies
+}
+export { computeDependencies }

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

@@ -19,6 +19,8 @@ export type Options = Partial<
      * @default ifNumericEnum
      */
     sortByValue: 'ifNumericEnum' | 'always' | 'never'
+    /** Enables experimental dependency detection. */
+    useExperimentalDependencyDetection: boolean
   } & AllCommonOptions<
     TypeOption,
     AdditionalSortOptions,