eslint-plugin-perfectionist 5.2.0 → 5.3.0

package/dist/rules/sort-classes.js

@@ -1,3 +1,4 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
 import {
   ORDER_ERROR,
   GROUP_ORDER_ERROR,
@@ -9,6 +10,11 @@ import {
   partitionByNewLineJsonSchema,
   partitionByCommentJsonSchema,
 } from '../utils/json-schemas/common-partition-json-schemas.js'
+import {
+  additionalCustomGroupMatchOptionsJsonSchema,
+  allSelectors,
+  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 {
@@ -16,20 +22,21 @@ import {
   buildCommonJsonSchemas,
 } from '../utils/json-schemas/common-json-schemas.js'
 import { defaultComparatorByOptionsComputer } from '../utils/compare/default-comparator-by-options-computer.js'
-import {
-  singleCustomGroupJsonSchema,
-  allSelectors,
-  allModifiers,
-} from './sort-classes/types.js'
+import { computeIndexSignatureDetails } from './sort-classes/node-info/compute-index-signature-details.js'
+import { computeStaticBlockDetails } from './sort-classes/node-info/compute-static-block-details.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'
 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 { UnreachableCaseError } from '../utils/unreachable-case-error.js'
 import { sortNodesByGroups } from '../utils/sort-nodes-by-groups.js'
 import { getNodeDecorators } from '../utils/get-node-decorators.js'
 import { createEslintRule } from '../utils/create-eslint-rule.js'
@@ -42,7 +49,6 @@ import { rangeToDiff } from '../utils/range-to-diff.js'
 import { getSettings } from '../utils/get-settings.js'
 import { isSortable } from '../utils/is-sortable.js'
 import { complete } from '../utils/complete.js'
-import { matches } from '../utils/matches.js'
 let cachedGroupsByModifiersAndSelectors = /* @__PURE__ */ new Map()
 const ORDER_ERROR_ID = 'unexpectedClassesOrder'
 const GROUP_ORDER_ERROR_ID = 'unexpectedClassesGroupOrder'
@@ -109,299 +115,88 @@ const sortClasses = createEslintRule({
         sourceCode,
       })
       let className = node.parent.id?.name
-      function getDependencyName(props) {
-        return `${props.isStatic ? 'static ' : ''}${props.isPrivateHash ? '#' : ''}${props.nodeNameWithoutStartingHash}`
-      }
-      let classMethodsDependencyNames = new Set(
-        node.body
-          .map(member => {
-            if (
-              (member.type === 'MethodDefinition' ||
-                member.type === 'TSAbstractMethodDefinition') &&
-              'name' in member.key
-            ) {
-              return getDependencyName({
-                isPrivateHash: member.key.type === 'PrivateIdentifier',
-                nodeNameWithoutStartingHash: member.key.name,
-                isStatic: member.static,
-              })
-            }
-            return null
-          })
-          .filter(Boolean),
-      )
-      function extractDependencies(expression, isMemberStatic) {
-        let dependencies = []
-        function checkNode(nodeValue) {
-          if (
-            nodeValue.type === 'MemberExpression' &&
-            (nodeValue.object.type === 'ThisExpression' ||
-              (nodeValue.object.type === 'Identifier' &&
-                nodeValue.object.name === className)) &&
-            (nodeValue.property.type === 'Identifier' ||
-              nodeValue.property.type === 'PrivateIdentifier')
-          ) {
-            let isStaticDependency =
-              isMemberStatic || nodeValue.object.type === 'Identifier'
-            let dependencyName = getDependencyName({
-              isPrivateHash: nodeValue.property.type === 'PrivateIdentifier',
-              nodeNameWithoutStartingHash: nodeValue.property.name,
-              isStatic: isStaticDependency,
-            })
-            if (!classMethodsDependencyNames.has(dependencyName)) {
-              dependencies.push(dependencyName)
-            }
-          }
-          if (nodeValue.type === 'Property') {
-            traverseNode(nodeValue.key)
-            traverseNode(nodeValue.value)
-          }
-          if (nodeValue.type === 'ConditionalExpression') {
-            traverseNode(nodeValue.test)
-            traverseNode(nodeValue.consequent)
-            traverseNode(nodeValue.alternate)
-          }
-          if (
-            'expression' in nodeValue &&
-            typeof nodeValue.expression !== 'boolean'
-          ) {
-            traverseNode(nodeValue.expression)
-          }
-          if ('object' in nodeValue) {
-            traverseNode(nodeValue.object)
-          }
-          if ('callee' in nodeValue) {
-            traverseNode(nodeValue.callee)
-          }
-          if ('init' in nodeValue && nodeValue.init) {
-            traverseNode(nodeValue.init)
-          }
-          if ('body' in nodeValue && nodeValue.body) {
-            traverseNode(nodeValue.body)
-          }
-          if ('left' in nodeValue) {
-            traverseNode(nodeValue.left)
-          }
-          if ('right' in nodeValue) {
-            traverseNode(nodeValue.right)
-          }
-          if ('elements' in nodeValue) {
-            let elements = nodeValue.elements.filter(
-              currentNode => currentNode !== null,
-            )
-            for (let element of elements) {
-              traverseNode(element)
-            }
-          }
-          if ('argument' in nodeValue && nodeValue.argument) {
-            traverseNode(nodeValue.argument)
-          }
-          if ('arguments' in nodeValue) {
-            let shouldIgnore = false
-            if (nodeValue.type === 'CallExpression') {
-              let functionName =
-                'name' in nodeValue.callee ? nodeValue.callee.name : null
-              shouldIgnore =
-                functionName !== null &&
-                matches(
-                  functionName,
-                  options.ignoreCallbackDependenciesPatterns,
-                )
-            }
-            if (!shouldIgnore) {
-              for (let argument of nodeValue.arguments) {
-                traverseNode(argument)
-              }
-            }
-          }
-          if ('declarations' in nodeValue) {
-            for (let declaration of nodeValue.declarations) {
-              traverseNode(declaration)
-            }
-          }
-          if ('properties' in nodeValue) {
-            for (let property of nodeValue.properties) {
-              traverseNode(property)
-            }
-          }
-          if ('expressions' in nodeValue) {
-            for (let nodeExpression of nodeValue.expressions) {
-              traverseNode(nodeExpression)
-            }
-          }
-        }
-        function traverseNode(nodeValue) {
-          if (Array.isArray(nodeValue)) {
-            for (let nodeItem of nodeValue) {
-              traverseNode(nodeItem)
-            }
-          } else {
-            checkNode(nodeValue)
-          }
-        }
-        traverseNode(expression)
-        return dependencies
-      }
       let overloadSignatureGroups = getOverloadSignatureGroups(node.body)
       let formattedNodes = node.body.reduce(
         (accumulator, member) => {
-          let name
           let dependencies = []
-          if (member.type === 'StaticBlock') {
-            name = 'static'
-          } else if (member.type === 'TSIndexSignature') {
-            name = sourceCode.text.slice(
-              member.range.at(0),
-              member.typeAnnotation?.range.at(0) ?? member.range.at(1),
-            )
-          } else if (member.key.type === 'Identifier') {
-            ;({ name } = member.key)
-          } else {
-            name = sourceCode.getText(member.key)
-          }
-          let isPrivateHash =
-            'key' in member && member.key.type === 'PrivateIdentifier'
-          let decorated = false
+          let isDecorated = false
           let decorators = []
           if ('decorators' in member) {
             decorators = getNodeDecorators(member).map(decorator =>
               getDecoratorName({ sourceCode, decorator }),
             )
-            decorated = decorators.length > 0
+            isDecorated = decorators.length > 0
           }
+          let addSafetySemicolonWhenInline
+          let dependencyNames
+          let name
           let memberValue
-          let modifiers = []
-          let selectors = []
-          let addSafetySemicolonWhenInline = true
+          let modifiers
+          let selectors
           switch (member.type) {
-            case 'TSAbstractPropertyDefinition':
-            case 'PropertyDefinition':
-              if ('static' in member && member.static) {
-                modifiers.push('static')
-              }
-              if ('declare' in member && member.declare) {
-                modifiers.push('declare')
-              }
-              if (member.type === 'TSAbstractPropertyDefinition') {
-                modifiers.push('abstract')
-              }
-              if (decorated) {
-                modifiers.push('decorated')
-              }
-              if ('override' in member && member.override) {
-                modifiers.push('override')
-              }
-              if ('readonly' in member && member.readonly) {
-                modifiers.push('readonly')
-              }
-              if (
-                'accessibility' in member &&
-                member.accessibility === 'protected'
-              ) {
-                modifiers.push('protected')
-              } else if (
-                ('accessibility' in member &&
-                  member.accessibility === 'private') ||
-                isPrivateHash
-              ) {
-                modifiers.push('private')
-              } else {
-                modifiers.push('public')
-              }
-              if ('optional' in member && member.optional) {
-                modifiers.push('optional')
-              }
-              if (
-                member.value?.type === 'ArrowFunctionExpression' ||
-                member.value?.type === 'FunctionExpression'
-              ) {
-                if (member.value.async) {
-                  modifiers.push('async')
-                }
-                selectors.push('function-property')
-              } else if (member.value) {
-                memberValue = sourceCode.getText(member.value)
-                dependencies = extractDependencies(member.value, member.static)
-              }
-              selectors.push('property')
+            case AST_NODE_TYPES.TSAbstractPropertyDefinition:
+            case AST_NODE_TYPES.PropertyDefinition:
+              addSafetySemicolonWhenInline = true
+              ;({
+                dependencyNames,
+                dependencies,
+                memberValue,
+                modifiers,
+                selectors,
+                name,
+              } = computePropertyDetails({
+                ignoreCallbackDependenciesPatterns:
+                  options.ignoreCallbackDependenciesPatterns,
+                property: member,
+                isDecorated,
+                sourceCode,
+                className,
+              }))
               break
-            case 'TSAbstractMethodDefinition':
-            case 'MethodDefinition':
-              if (member.static) {
-                modifiers.push('static')
-              }
-              if (member.type === 'TSAbstractMethodDefinition') {
-                modifiers.push('abstract')
-              } else if (!node.parent.declare) {
-                addSafetySemicolonWhenInline = false
-              }
-              if (decorated) {
-                modifiers.push('decorated')
-              }
-              if (member.override) {
-                modifiers.push('override')
-              }
-              if (member.accessibility === 'protected') {
-                modifiers.push('protected')
-              } else if (member.accessibility === 'private' || isPrivateHash) {
-                modifiers.push('private')
-              } else {
-                modifiers.push('public')
-              }
-              if (member.optional) {
-                modifiers.push('optional')
-              }
-              if (member.value.async) {
-                modifiers.push('async')
-              }
-              if (member.kind === 'constructor') {
-                selectors.push('constructor')
-              }
-              if (member.kind === 'get') {
-                selectors.push('get-method')
-              }
-              if (member.kind === 'set') {
-                selectors.push('set-method')
-              }
-              selectors.push('method')
+            case AST_NODE_TYPES.TSAbstractMethodDefinition:
+            case AST_NODE_TYPES.MethodDefinition:
+              dependencyNames = []
+              ;({ addSafetySemicolonWhenInline, selectors, modifiers, name } =
+                computeMethodDetails({
+                  hasParentDeclare: node.parent.declare,
+                  method: member,
+                  isDecorated,
+                  sourceCode,
+                }))
               break
-            case 'TSAbstractAccessorProperty':
-            case 'AccessorProperty':
-              if (member.static) {
-                modifiers.push('static')
-              }
-              if (member.type === 'TSAbstractAccessorProperty') {
-                modifiers.push('abstract')
-              }
-              if (decorated) {
-                modifiers.push('decorated')
-              }
-              if (member.override) {
-                modifiers.push('override')
-              }
-              if (member.accessibility === 'protected') {
-                modifiers.push('protected')
-              } else if (member.accessibility === 'private' || isPrivateHash) {
-                modifiers.push('private')
-              } else {
-                modifiers.push('public')
-              }
-              selectors.push('accessor-property')
+            case AST_NODE_TYPES.TSAbstractAccessorProperty:
+            case AST_NODE_TYPES.AccessorProperty:
+              addSafetySemicolonWhenInline = true
+              ;({ dependencyNames, selectors, modifiers, name } =
+                computeAccessorDetails({
+                  accessor: member,
+                  isDecorated,
+                  sourceCode,
+                }))
               break
-            case 'TSIndexSignature':
-              if (member.static) {
-                modifiers.push('static')
-              }
-              if (member.readonly) {
-                modifiers.push('readonly')
-              }
-              selectors.push('index-signature')
+            case AST_NODE_TYPES.TSIndexSignature:
+              addSafetySemicolonWhenInline = true
+              dependencyNames = []
+              ;({ modifiers, selectors, name } = computeIndexSignatureDetails({
+                indexSignature: member,
+                sourceCode,
+              }))
               break
-            case 'StaticBlock':
+            case AST_NODE_TYPES.StaticBlock:
               addSafetySemicolonWhenInline = false
-              selectors.push('static-block')
-              dependencies = extractDependencies(member, true)
+              dependencyNames = []
+              name = 'static'
+              ;({ dependencies, selectors, modifiers } =
+                computeStaticBlockDetails({
+                  ignoreCallbackDependenciesPatterns:
+                    options.ignoreCallbackDependenciesPatterns,
+                  staticBlock: member,
+                  className,
+                }))
               break
+            /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+            default:
+              throw new UnreachableCaseError(member)
           }
           let predefinedGroups = generatePredefinedGroups({
             cache: cachedGroupsByModifiersAndSelectors,
@@ -428,15 +223,6 @@ const sortClasses = createEslintRule({
           let overloadSignatureGroupMember =
             overloadSignatureGroups[overloadSignatureGroupMemberIndex]?.at(-1)
           let sortingNode = {
-            dependencyNames: [
-              getDependencyName({
-                nodeNameWithoutStartingHash: name.startsWith('#')
-                  ? name.slice(1)
-                  : name,
-                isStatic: modifiers.includes('static'),
-                isPrivateHash,
-              }),
-            ],
             overloadSignaturesGroupId:
               overloadSignatureGroupMemberIndex === -1
                 ? null
@@ -446,6 +232,7 @@ const sortClasses = createEslintRule({
               : rangeToDiff(member, sourceCode),
             isEslintDisabled: isNodeEslintDisabled(member, eslintDisabledLines),
             addSafetySemicolonWhenInline,
+            dependencyNames,
             node: member,
             dependencies,
             group,
@@ -523,7 +310,8 @@ const sortClasses = createEslintRule({
         properties: {
           ...buildCommonJsonSchemas(),
           ...buildCommonGroupsJsonSchemas({
-            singleCustomGroupJsonSchema,
+            additionalCustomGroupMatchProperties:
+              additionalCustomGroupMatchOptionsJsonSchema,
           }),
           ignoreCallbackDependenciesPatterns: buildRegexJsonSchema(),
           partitionByComment: partitionByCommentJsonSchema,

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

@@ -1,7 +1,6 @@
 import { TSESTree } from '@typescript-eslint/types'
-import { CommonPartitionOptions } from '../../types/common-partition-options.js'
-import { CommonGroupsOptions } from '../../types/common-groups-options.js'
-import { CommonOptions, TypeOption } from '../../types/common-options.js'
+import { AllCommonOptions } from '../../types/all-common-options.js'
+import { TypeOption } from '../../types/common-options.js'
 import { SortingNode } from '../../types/sorting-node.js'
 export type Options = Partial<
   {
@@ -10,15 +9,14 @@ export type Options = Partial<
     sortOnAccessors: boolean
     sortOnMethods: boolean
     sortOnClasses: boolean
-  } & CommonGroupsOptions<
-    SingleCustomGroup,
-    Record<string, never>,
-    TypeOption
-  > &
-    CommonOptions<TypeOption> &
-    CommonPartitionOptions
+  } & AllCommonOptions<
+    TypeOption,
+    AdditionalSortOptions,
+    CustomGroupMatchOptions
+  >
 >[]
 export type SortDecoratorsSortingNode = SortingNode<TSESTree.Decorator>
-/** Additional configuration for a single custom group. */
-type SingleCustomGroup = Record<string, never>
+/** Match options for a custom group. */
+type CustomGroupMatchOptions = object
+type AdditionalSortOptions = object
 export {}

package/dist/rules/sort-decorators.js

@@ -1,3 +1,4 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
 import {
   partitionByNewLineJsonSchema,
   partitionByCommentJsonSchema,
@@ -54,60 +55,6 @@ let defaultOptions = {
   groups: [],
 }
 const sortDecorators = createEslintRule({
-  meta: {
-    schema: {
-      items: {
-        properties: {
-          ...buildCommonJsonSchemas(),
-          ...buildCommonGroupsJsonSchemas(),
-          sortOnParameters: {
-            description:
-              'Controls whether sorting should be enabled for method parameter decorators.',
-            type: 'boolean',
-          },
-          sortOnProperties: {
-            description:
-              'Controls whether sorting should be enabled for class property decorators.',
-            type: 'boolean',
-          },
-          sortOnAccessors: {
-            description:
-              'Controls whether sorting should be enabled for class accessor decorators.',
-            type: 'boolean',
-          },
-          sortOnMethods: {
-            description:
-              'Controls whether sorting should be enabled for class method decorators.',
-            type: 'boolean',
-          },
-          sortOnClasses: {
-            description:
-              'Controls whether sorting should be enabled for class decorators.',
-            type: 'boolean',
-          },
-          partitionByComment: partitionByCommentJsonSchema,
-          partitionByNewLine: partitionByNewLineJsonSchema,
-        },
-        additionalProperties: false,
-        type: 'object',
-      },
-      uniqueItems: true,
-      type: 'array',
-    },
-    messages: {
-      [MISSED_SPACING_ERROR_ID]: MISSED_SPACING_ERROR,
-      [EXTRA_SPACING_ERROR_ID]: EXTRA_SPACING_ERROR,
-      [GROUP_ORDER_ERROR_ID]: GROUP_ORDER_ERROR,
-      [ORDER_ERROR_ID]: ORDER_ERROR,
-    },
-    docs: {
-      url: 'https://perfectionist.dev/rules/sort-decorators',
-      description: 'Enforce sorted decorators.',
-      recommended: true,
-    },
-    type: 'suggestion',
-    fixable: 'code',
-  },
   create: context => {
     let settings = getSettings(context.settings)
     let options = complete(context.options.at(0), settings, defaultOptions)
@@ -125,8 +72,8 @@ const sortDecorators = createEslintRule({
         }
         if (
           'decorators' in decorator.parent &&
-          decorator.parent.type === 'Identifier' &&
-          decorator.parent.parent.type === 'FunctionExpression'
+          decorator.parent.type === AST_NODE_TYPES.Identifier &&
+          decorator.parent.parent.type === AST_NODE_TYPES.FunctionExpression
         ) {
           let { decorators } = decorator.parent
           if (decorator !== decorators[0]) {
@@ -165,6 +112,60 @@ const sortDecorators = createEslintRule({
           : null,
     }
   },
+  meta: {
+    schema: {
+      items: {
+        properties: {
+          ...buildCommonJsonSchemas(),
+          ...buildCommonGroupsJsonSchemas(),
+          sortOnParameters: {
+            description:
+              'Controls whether sorting should be enabled for method parameter decorators.',
+            type: 'boolean',
+          },
+          sortOnProperties: {
+            description:
+              'Controls whether sorting should be enabled for class property decorators.',
+            type: 'boolean',
+          },
+          sortOnAccessors: {
+            description:
+              'Controls whether sorting should be enabled for class accessor decorators.',
+            type: 'boolean',
+          },
+          sortOnMethods: {
+            description:
+              'Controls whether sorting should be enabled for class method decorators.',
+            type: 'boolean',
+          },
+          sortOnClasses: {
+            description:
+              'Controls whether sorting should be enabled for class decorators.',
+            type: 'boolean',
+          },
+          partitionByComment: partitionByCommentJsonSchema,
+          partitionByNewLine: partitionByNewLineJsonSchema,
+        },
+        additionalProperties: false,
+        type: 'object',
+      },
+      uniqueItems: true,
+      type: 'array',
+    },
+    messages: {
+      [MISSED_SPACING_ERROR_ID]: MISSED_SPACING_ERROR,
+      [EXTRA_SPACING_ERROR_ID]: EXTRA_SPACING_ERROR,
+      [GROUP_ORDER_ERROR_ID]: GROUP_ORDER_ERROR,
+      [ORDER_ERROR_ID]: ORDER_ERROR,
+    },
+    docs: {
+      url: 'https://perfectionist.dev/rules/sort-decorators',
+      description: 'Enforce sorted decorators.',
+      recommended: true,
+    },
+    type: 'suggestion',
+    fixable: 'code',
+  },
   defaultOptions: [defaultOptions],
   name: 'sort-decorators',
 })

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

@@ -28,6 +28,9 @@ function buildComparatorByOptionsComputer(isNumericEnum) {
 }
 let byNonNumericValueComparatorComputer = options => {
   switch (options.type) {
+    /* v8 ignore next 2 -- @preserve Untested for now as not a relevant sort for this rule. */
+    case 'subgroup-order':
+      return defaultComparatorByOptionsComputer(options)
     case 'alphabetical':
       return (a, b) =>
         compareAlphabetically(a.value ?? '', b.value ?? '', options)
@@ -47,6 +50,9 @@ let byNonNumericValueComparatorComputer = options => {
 }
 let byNumericValueComparatorComputer = options => {
   switch (options.type) {
+    /* v8 ignore next 2 -- @preserve Untested for now as not a relevant sort for this rule. */
+    case 'subgroup-order':
+      return defaultComparatorByOptionsComputer(options)
     case 'alphabetical':
     case 'line-length':
     case 'natural':