eslint-plugin-perfectionist 3.1.3 → 3.3.0

package/dist/index.d.ts

@@ -266,7 +266,7 @@ declare const _default: {
       RuleListener
     >
     'sort-classes': RuleModule<
-      'unexpectedClassesOrder',
+      'unexpectedClassesGroupOrder' | 'unexpectedClassesOrder',
       [
         Partial<{
           customGroups: {
@@ -348,14 +348,7 @@ declare const _default: {
     >
     'sort-enums': RuleModule<
       'unexpectedEnumsOrder',
-      [
-        Partial<{
-          type: 'alphabetical' | 'line-length' | 'natural'
-          partitionByComment: string[] | boolean | string
-          order: 'desc' | 'asc'
-          ignoreCase: boolean
-        }>,
-      ],
+      Options,
       unknown,
       RuleListener
     >
@@ -375,5 +368,16 @@ declare const _default: {
   name: string
 }
 
+declare type Options = [
+  Partial<{
+    type: 'alphabetical' | 'line-length' | 'natural'
+    partitionByComment: string[] | boolean | string
+    forceNumericSort: boolean
+    order: 'desc' | 'asc'
+    sortByValue: boolean
+    ignoreCase: boolean
+  }>,
+]
+
 export {}
 export = _default

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

@@ -4,6 +4,7 @@ const getGroupNumber = require('../utils/get-group-number.js')
 const getSourceCode = require('../utils/get-source-code.js')
 const toSingleLine = require('../utils/to-single-line.js')
 const rangeToDiff = require('../utils/range-to-diff.js')
+const getSettings = require('../utils/get-settings.js')
 const isPositive = require('../utils/is-positive.js')
 const sortNodes = require('../utils/sort-nodes.js')
 const makeFixes = require('../utils/make-fixes.js')
@@ -72,8 +73,9 @@ const sortArrayIncludes = createEslintRule.createEslintRule({
           node.object.type === 'ArrayExpression'
             ? node.object.elements
             : node.object.arguments
+        let settings = getSettings.getSettings(context.settings)
         if (elements.length > 1) {
-          let options = complete.complete(context.options.at(0), {
+          let options = complete.complete(context.options.at(0), settings, {
             groupKind: 'literals-first',
             type: 'alphabetical',
             ignoreCase: true,

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

@@ -3,6 +3,7 @@ import { getGroupNumber } from '../utils/get-group-number.mjs'
 import { getSourceCode } from '../utils/get-source-code.mjs'
 import { toSingleLine } from '../utils/to-single-line.mjs'
 import { rangeToDiff } from '../utils/range-to-diff.mjs'
+import { getSettings } from '../utils/get-settings.mjs'
 import { isPositive } from '../utils/is-positive.mjs'
 import { sortNodes } from '../utils/sort-nodes.mjs'
 import { makeFixes } from '../utils/make-fixes.mjs'
@@ -71,8 +72,9 @@ const sortArrayIncludes = createEslintRule({
           node.object.type === 'ArrayExpression'
             ? node.object.elements
             : node.object.arguments
+        let settings = getSettings(context.settings)
         if (elements.length > 1) {
-          let options = complete(context.options.at(0), {
+          let options = complete(context.options.at(0), settings, {
             groupKind: 'literals-first',
             type: 'alphabetical',
             ignoreCase: true,

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

@@ -4,6 +4,7 @@ const createEslintRule = require('../utils/create-eslint-rule.js')
 const getGroupNumber = require('../utils/get-group-number.js')
 const getSourceCode = require('../utils/get-source-code.js')
 const rangeToDiff = require('../utils/range-to-diff.js')
+const getSettings = require('../utils/get-settings.js')
 const isPositive = require('../utils/is-positive.js')
 const useGroups = require('../utils/use-groups.js')
 const makeFixes = require('../utils/make-fixes.js')
@@ -100,7 +101,8 @@ const sortAstroAttributes = createEslintRule.createEslintRule({
       JSXElement: node => {
         let { attributes } = node.openingElement
         if (attributes.length > 1) {
-          let options = complete.complete(context.options.at(0), {
+          let settings = getSettings.getSettings(context.settings)
+          let options = complete.complete(context.options.at(0), settings, {
             type: 'alphabetical',
             ignoreCase: true,
             customGroups: {},

package/dist/rules/sort-astro-attributes.mjs

@@ -3,6 +3,7 @@ import { createEslintRule } from '../utils/create-eslint-rule.mjs'
 import { getGroupNumber } from '../utils/get-group-number.mjs'
 import { getSourceCode } from '../utils/get-source-code.mjs'
 import { rangeToDiff } from '../utils/range-to-diff.mjs'
+import { getSettings } from '../utils/get-settings.mjs'
 import { isPositive } from '../utils/is-positive.mjs'
 import { useGroups } from '../utils/use-groups.mjs'
 import { makeFixes } from '../utils/make-fixes.mjs'
@@ -99,7 +100,8 @@ const sortAstroAttributes = createEslintRule({
       JSXElement: node => {
         let { attributes } = node.openingElement
         if (attributes.length > 1) {
-          let options = complete(context.options.at(0), {
+          let settings = getSettings(context.settings)
+          let options = complete(context.options.at(0), settings, {
             type: 'alphabetical',
             ignoreCase: true,
             customGroups: {},

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

@@ -0,0 +1,99 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+const cachedGroupsByModifiersAndSelectors = /* @__PURE__ */ new Map()
+const generateOfficialGroups = (modifiers, selectors) => {
+  let modifiersAndSelectorsKey = modifiers.join('&') + '/' + selectors.join('&')
+  let cachedValue = cachedGroupsByModifiersAndSelectors.get(
+    modifiersAndSelectorsKey,
+  )
+  if (cachedValue) {
+    return cachedValue
+  }
+  let allModifiersCombinations = []
+  for (let i = modifiers.length; i > 0; i--) {
+    allModifiersCombinations = [
+      ...allModifiersCombinations,
+      ...getCombinations(modifiers, i),
+    ]
+  }
+  let allModifiersCombinationPermutations = allModifiersCombinations.flatMap(
+    result => getPermutations(result),
+  )
+  let returnValue = []
+  for (let selector of selectors) {
+    returnValue = [
+      ...returnValue,
+      ...allModifiersCombinationPermutations.map(
+        modifiersCombinationPermutation =>
+          [...modifiersCombinationPermutation, selector].join('-'),
+      ),
+      selector,
+    ]
+  }
+  cachedGroupsByModifiersAndSelectors.set(modifiersAndSelectorsKey, returnValue)
+  return returnValue
+}
+const getCombinations = (array, n) => {
+  let result = []
+  let backtrack = (start, comb) => {
+    if (comb.length === n) {
+      result.push([...comb])
+      return
+    }
+    for (let i = start; i < array.length; i++) {
+      comb.push(array[i])
+      backtrack(i + 1, comb)
+      comb.pop()
+    }
+  }
+  backtrack(0, [])
+  return result
+}
+const getPermutations = elements => {
+  let result = []
+  let backtrack = first => {
+    if (first === elements.length) {
+      result.push([...elements])
+      return
+    }
+    for (let i = first; i < elements.length; i++) {
+      ;[elements[first], elements[i]] = [elements[i], elements[first]]
+      backtrack(first + 1)
+      ;[elements[first], elements[i]] = [elements[i], elements[first]]
+    }
+  }
+  backtrack(0)
+  return result
+}
+const getOverloadSignatureGroups = members => {
+  let methods = members
+    .filter(
+      member =>
+        member.type === 'MethodDefinition' ||
+        member.type === 'TSAbstractMethodDefinition',
+    )
+    .filter(member => member.kind === 'method')
+  let staticOverloadSignaturesByName = /* @__PURE__ */ new Map()
+  let overloadSignaturesByName = /* @__PURE__ */ new Map()
+  for (let method of methods) {
+    if (method.key.type !== 'Identifier') {
+      continue
+    }
+    let { name } = method.key
+    let mapToUse = method.static
+      ? staticOverloadSignaturesByName
+      : overloadSignaturesByName
+    let signatureOverloadsGroup = mapToUse.get(name)
+    if (!signatureOverloadsGroup) {
+      signatureOverloadsGroup = []
+      mapToUse.set(name, signatureOverloadsGroup)
+    }
+    signatureOverloadsGroup.push(method)
+  }
+  return [
+    ...overloadSignaturesByName.values(),
+    ...staticOverloadSignaturesByName.values(),
+  ].filter(group => group.length > 1)
+}
+exports.generateOfficialGroups = generateOfficialGroups
+exports.getOverloadSignatureGroups = getOverloadSignatureGroups

package/dist/rules/sort-classes-utils.mjs

@@ -0,0 +1,96 @@
+const cachedGroupsByModifiersAndSelectors = /* @__PURE__ */ new Map()
+const generateOfficialGroups = (modifiers, selectors) => {
+  let modifiersAndSelectorsKey = modifiers.join('&') + '/' + selectors.join('&')
+  let cachedValue = cachedGroupsByModifiersAndSelectors.get(
+    modifiersAndSelectorsKey,
+  )
+  if (cachedValue) {
+    return cachedValue
+  }
+  let allModifiersCombinations = []
+  for (let i = modifiers.length; i > 0; i--) {
+    allModifiersCombinations = [
+      ...allModifiersCombinations,
+      ...getCombinations(modifiers, i),
+    ]
+  }
+  let allModifiersCombinationPermutations = allModifiersCombinations.flatMap(
+    result => getPermutations(result),
+  )
+  let returnValue = []
+  for (let selector of selectors) {
+    returnValue = [
+      ...returnValue,
+      ...allModifiersCombinationPermutations.map(
+        modifiersCombinationPermutation =>
+          [...modifiersCombinationPermutation, selector].join('-'),
+      ),
+      selector,
+    ]
+  }
+  cachedGroupsByModifiersAndSelectors.set(modifiersAndSelectorsKey, returnValue)
+  return returnValue
+}
+const getCombinations = (array, n) => {
+  let result = []
+  let backtrack = (start, comb) => {
+    if (comb.length === n) {
+      result.push([...comb])
+      return
+    }
+    for (let i = start; i < array.length; i++) {
+      comb.push(array[i])
+      backtrack(i + 1, comb)
+      comb.pop()
+    }
+  }
+  backtrack(0, [])
+  return result
+}
+const getPermutations = elements => {
+  let result = []
+  let backtrack = first => {
+    if (first === elements.length) {
+      result.push([...elements])
+      return
+    }
+    for (let i = first; i < elements.length; i++) {
+      ;[elements[first], elements[i]] = [elements[i], elements[first]]
+      backtrack(first + 1)
+      ;[elements[first], elements[i]] = [elements[i], elements[first]]
+    }
+  }
+  backtrack(0)
+  return result
+}
+const getOverloadSignatureGroups = members => {
+  let methods = members
+    .filter(
+      member =>
+        member.type === 'MethodDefinition' ||
+        member.type === 'TSAbstractMethodDefinition',
+    )
+    .filter(member => member.kind === 'method')
+  let staticOverloadSignaturesByName = /* @__PURE__ */ new Map()
+  let overloadSignaturesByName = /* @__PURE__ */ new Map()
+  for (let method of methods) {
+    if (method.key.type !== 'Identifier') {
+      continue
+    }
+    let { name } = method.key
+    let mapToUse = method.static
+      ? staticOverloadSignaturesByName
+      : overloadSignaturesByName
+    let signatureOverloadsGroup = mapToUse.get(name)
+    if (!signatureOverloadsGroup) {
+      signatureOverloadsGroup = []
+      mapToUse.set(name, signatureOverloadsGroup)
+    }
+    signatureOverloadsGroup.push(method)
+  }
+  return [
+    ...overloadSignaturesByName.values(),
+    ...staticOverloadSignaturesByName.values(),
+  ].filter(group => group.length > 1)
+}
+export { generateOfficialGroups, getOverloadSignatureGroups }

package/dist/rules/sort-classes.js

@@ -1,4 +1,5 @@
 'use strict'
+const sortClassesUtils = require('./sort-classes-utils.js')
 const isPartitionComment = require('../utils/is-partition-comment.js')
 const getCommentBefore = require('../utils/get-comment-before.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
@@ -6,6 +7,7 @@ const getGroupNumber = require('../utils/get-group-number.js')
 const getSourceCode = require('../utils/get-source-code.js')
 const toSingleLine = require('../utils/to-single-line.js')
 const rangeToDiff = require('../utils/range-to-diff.js')
+const getSettings = require('../utils/get-settings.js')
 const isPositive = require('../utils/is-positive.js')
 const useGroups = require('../utils/use-groups.js')
 const sortNodes = require('../utils/sort-nodes.js')
@@ -98,6 +100,8 @@ const sortClasses = createEslintRule.createEslintRule({
       },
     ],
     messages: {
+      unexpectedClassesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedClassesOrder: 'Expected "{{right}}" to come before "{{left}}".',
     },
   },
@@ -108,11 +112,12 @@ const sortClasses = createEslintRule.createEslintRule({
       ignoreCase: true,
       partitionByComment: false,
       groups: [
+        'static-block',
         'index-signature',
         'static-property',
-        'protected-property',
-        'private-property',
-        'property',
+        ['protected-property', 'protected-accessor-property'],
+        ['private-property', 'private-accessor-property'],
+        ['property', 'accessor-property'],
         'constructor',
         'static-method',
         'protected-method',
@@ -127,13 +132,15 @@ const sortClasses = createEslintRule.createEslintRule({
   create: context => ({
     ClassBody: node => {
       if (node.body.length > 1) {
-        let options = complete.complete(context.options.at(0), {
+        let settings = getSettings.getSettings(context.settings)
+        let options = complete.complete(context.options.at(0), settings, {
           groups: [
+            'static-block',
             'index-signature',
             'static-property',
-            'protected-property',
-            'private-property',
-            'property',
+            ['protected-property', 'protected-accessor-property'],
+            ['private-property', 'private-accessor-property'],
+            ['property', 'accessor-property'],
             'constructor',
             'static-method',
             'protected-method',
@@ -187,9 +194,11 @@ const sortClasses = createEslintRule.createEslintRule({
           traverseNode(expression)
           return dependencies
         }
+        let overloadSignatureGroups =
+          sortClassesUtils.getOverloadSignatureGroups(node.body)
         let formattedNodes = node.body.reduce(
           (accumulator, member) => {
-            var _a
+            var _a, _b, _c, _d
             let comment = getCommentBefore.getCommentBefore(member, sourceCode)
             if (
               options.partitionByComment &&
@@ -221,80 +230,126 @@ const sortClasses = createEslintRule.createEslintRule({
                 name = sourceCode.text.slice(...member.key.range)
               }
             }
-            let isPrivate = name.startsWith('_') || name.startsWith('#')
+            let isPrivateHash =
+              'key' in member && member.key.type === 'PrivateIdentifier'
             let decorated =
               'decorators' in member && member.decorators.length > 0
-            if (member.type === 'MethodDefinition') {
-              if (member.kind === 'constructor') {
-                defineGroup('constructor')
+            let modifiers = []
+            let selectors = []
+            if (
+              member.type === 'MethodDefinition' ||
+              member.type === 'TSAbstractMethodDefinition'
+            ) {
+              if (member.static) {
+                modifiers.push('static')
               }
-              let isProtectedMethod = member.accessibility === 'protected'
-              let isPrivateMethod =
-                member.accessibility === 'private' || isPrivate
-              let isStaticMethod = member.static
-              if (decorated) {
-                if (member.kind === 'get') {
-                  defineGroup('decorated-get-method')
-                }
-                if (member.kind === 'set') {
-                  defineGroup('decorated-set-method')
-                }
-                defineGroup('decorated-method')
+              if (member.type === 'TSAbstractMethodDefinition') {
+                modifiers.push('abstract')
               }
-              if (isPrivateMethod && isStaticMethod) {
-                defineGroup('static-private-method')
+              if (decorated) {
+                modifiers.push('decorated')
               }
-              if (isPrivateMethod) {
-                defineGroup('private-method')
+              if (member.override) {
+                modifiers.push('override')
               }
-              if (isStaticMethod) {
-                defineGroup('static-method')
+              if (member.accessibility === 'protected') {
+                modifiers.push('protected')
+              } else if (member.accessibility === 'private' || isPrivateHash) {
+                modifiers.push('private')
+              } else {
+                modifiers.push('public')
               }
-              if (isProtectedMethod && isStaticMethod) {
-                defineGroup('static-protected-method')
+              if (member.optional) {
+                modifiers.push('optional')
               }
-              if (isProtectedMethod) {
-                defineGroup('protected-method')
+              if (member.kind === 'constructor') {
+                selectors.push('constructor')
               }
               if (member.kind === 'get') {
-                defineGroup('get-method')
+                selectors.push('get-method')
               }
               if (member.kind === 'set') {
-                defineGroup('set-method')
+                selectors.push('set-method')
               }
-              defineGroup('method')
+              selectors.push('method')
             } else if (member.type === 'TSIndexSignature') {
-              defineGroup('index-signature')
-            } else if (member.type === 'AccessorProperty') {
+              if (member.static) {
+                modifiers.push('static')
+              }
+              if (member.readonly) {
+                modifiers.push('readonly')
+              }
+              selectors.push('index-signature')
+            } else if (member.type === 'StaticBlock') {
+              selectors.push('static-block')
+            } else if (
+              member.type === 'AccessorProperty' ||
+              member.type === 'TSAbstractAccessorProperty'
+            ) {
+              if (member.static) {
+                modifiers.push('static')
+              }
+              if (member.type === 'TSAbstractAccessorProperty') {
+                modifiers.push('abstract')
+              }
               if (decorated) {
-                if (member.accessibility === 'protected') {
-                  defineGroup('protected-decorated-accessor-property')
-                }
-                if (member.accessibility === 'private' || isPrivate) {
-                  defineGroup('private-decorated-accessor-property')
-                }
-                defineGroup('decorated-accessor-property')
+                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')
+            } else {
+              if (member.static) {
+                modifiers.push('static')
+              }
+              if (member.declare) {
+                modifiers.push('declare')
+              }
+              if (member.type === 'TSAbstractPropertyDefinition') {
+                modifiers.push('abstract')
               }
-            } else if (member.type === 'PropertyDefinition') {
               if (decorated) {
-                if (member.accessibility === 'protected') {
-                  defineGroup('protected-decorated-property')
-                }
-                if (member.accessibility === 'private' || isPrivate) {
-                  defineGroup('private-decorated-property')
-                }
-                defineGroup('decorated-property')
+                modifiers.push('decorated')
+              }
+              if (member.override) {
+                modifiers.push('override')
+              }
+              if (member.readonly) {
+                modifiers.push('readonly')
               }
               if (member.accessibility === 'protected') {
-                defineGroup('protected-property')
+                modifiers.push('protected')
+              } else if (member.accessibility === 'private' || isPrivateHash) {
+                modifiers.push('private')
+              } else {
+                modifiers.push('public')
               }
-              if (member.accessibility === 'private' || isPrivate) {
-                defineGroup('private-property')
+              if (member.optional) {
+                modifiers.push('optional')
               }
-              if (member.static) {
-                defineGroup('static-property')
+              if (
+                ((_b = member.value) == null ? void 0 : _b.type) ===
+                  'ArrowFunctionExpression' ||
+                ((_c = member.value) == null ? void 0 : _c.type) ===
+                  'FunctionExpression'
+              ) {
+                selectors.push('function-property')
               }
-              defineGroup('property')
+              selectors.push('property')
+            }
+            for (let officialGroup of sortClassesUtils.generateOfficialGroups(
+              modifiers,
+              selectors,
+            )) {
+              defineGroup(officialGroup)
             }
             setCustomGroups(options.customGroups, name, {
               override: true,
@@ -302,8 +357,16 @@ const sortClasses = createEslintRule.createEslintRule({
             if (member.type === 'PropertyDefinition' && member.value) {
               dependencies = extractDependencies(member.value)
             }
+            let overloadSignatureGroupMember =
+              (_d = overloadSignatureGroups.find(overloadSignatures =>
+                overloadSignatures.includes(member),
+              )) == null
+                ? void 0
+                : _d.at(-1)
             let value = {
-              size: rangeToDiff.rangeToDiff(member.range),
+              size: overloadSignatureGroupMember
+                ? rangeToDiff.rangeToDiff(overloadSignatureGroupMember.range)
+                : rangeToDiff.rangeToDiff(member.range),
               group: getGroup(),
               node: member,
               dependencies,
@@ -318,43 +381,57 @@ const sortClasses = createEslintRule.createEslintRule({
           pairwise.pairwise(nodes, (left, right) => {
             let leftNum = getGroupNumber.getGroupNumber(options.groups, left)
             let rightNum = getGroupNumber.getGroupNumber(options.groups, right)
+            let isLeftOrRightIgnored =
+              leftNum === options.groups.length ||
+              rightNum === options.groups.length
             if (
-              left.name !== right.name &&
+              !isLeftOrRightIgnored &&
               (leftNum > rightNum ||
                 (leftNum === rightNum &&
                   isPositive.isPositive(compare.compare(left, right, options))))
             ) {
               context.report({
-                messageId: 'unexpectedClassesOrder',
+                messageId:
+                  leftNum !== rightNum
+                    ? 'unexpectedClassesGroupOrder'
+                    : 'unexpectedClassesOrder',
                 data: {
                   left: toSingleLine.toSingleLine(left.name),
+                  leftGroup: left.group,
                   right: toSingleLine.toSingleLine(right.name),
+                  rightGroup: right.group,
                 },
                 node: right.node,
                 fix: fixer => {
-                  let grouped = nodes.reduce((accumulator, sortingNode) => {
+                  let nodesByNonIgnoredGroupNumber = {}
+                  let ignoredNodeIndices = []
+                  for (let [index, sortingNode] of nodes.entries()) {
                     let groupNum = getGroupNumber.getGroupNumber(
                       options.groups,
                       sortingNode,
                     )
-                    if (!(groupNum in accumulator)) {
-                      accumulator[groupNum] = [sortingNode]
-                    } else {
-                      accumulator[groupNum] = sortNodes.sortNodes(
-                        [...accumulator[groupNum], sortingNode],
-                        options,
-                      )
+                    if (groupNum === options.groups.length) {
+                      ignoredNodeIndices.push(index)
+                      continue
                     }
-                    return accumulator
-                  }, {})
+                    nodesByNonIgnoredGroupNumber[groupNum] =
+                      nodesByNonIgnoredGroupNumber[groupNum] ?? []
+                    nodesByNonIgnoredGroupNumber[groupNum].push(sortingNode)
+                  }
                   let sortedNodes = []
-                  for (let group of Object.keys(grouped).sort(
-                    (a, b) => Number(a) - Number(b),
-                  )) {
+                  for (let groupNumber of Object.keys(
+                    nodesByNonIgnoredGroupNumber,
+                  ).sort((a, b) => Number(a) - Number(b))) {
                     sortedNodes.push(
-                      ...sortNodes.sortNodes(grouped[group], options),
+                      ...sortNodes.sortNodes(
+                        nodesByNonIgnoredGroupNumber[Number(groupNumber)],
+                        options,
+                      ),
                     )
                   }
+                  for (let ignoredIndex of ignoredNodeIndices) {
+                    sortedNodes.splice(ignoredIndex, 0, nodes[ignoredIndex])
+                  }
                   return makeFixes.makeFixes(
                     fixer,
                     nodes,