eslint-plugin-perfectionist 3.1.3 → 3.3.0

package/dist/rules/sort-classes.mjs

@@ -1,3 +1,7 @@
+import {
+  getOverloadSignatureGroups,
+  generateOfficialGroups,
+} from './sort-classes-utils.mjs'
 import { isPartitionComment } from '../utils/is-partition-comment.mjs'
 import { getCommentBefore } from '../utils/get-comment-before.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
@@ -5,6 +9,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 { useGroups } from '../utils/use-groups.mjs'
 import { sortNodes } from '../utils/sort-nodes.mjs'
@@ -97,6 +102,8 @@ const sortClasses = createEslintRule({
       },
     ],
     messages: {
+      unexpectedClassesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedClassesOrder: 'Expected "{{right}}" to come before "{{left}}".',
     },
   },
@@ -107,11 +114,12 @@ const sortClasses = 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',
@@ -126,13 +134,15 @@ const sortClasses = createEslintRule({
   create: context => ({
     ClassBody: node => {
       if (node.body.length > 1) {
-        let options = complete(context.options.at(0), {
+        let settings = getSettings(context.settings)
+        let options = 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',
@@ -186,9 +196,10 @@ const sortClasses = createEslintRule({
           traverseNode(expression)
           return dependencies
         }
+        let overloadSignatureGroups = getOverloadSignatureGroups(node.body)
         let formattedNodes = node.body.reduce(
           (accumulator, member) => {
-            var _a
+            var _a, _b, _c, _d
             let comment = getCommentBefore(member, sourceCode)
             if (
               options.partitionByComment &&
@@ -218,80 +229,126 @@ const sortClasses = 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 generateOfficialGroups(
+              modifiers,
+              selectors,
+            )) {
+              defineGroup(officialGroup)
             }
             setCustomGroups(options.customGroups, name, {
               override: true,
@@ -299,8 +356,16 @@ const sortClasses = 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(member.range),
+              size: overloadSignatureGroupMember
+                ? rangeToDiff(overloadSignatureGroupMember.range)
+                : rangeToDiff(member.range),
               group: getGroup(),
               node: member,
               dependencies,
@@ -315,37 +380,53 @@ const sortClasses = createEslintRule({
           pairwise(nodes, (left, right) => {
             let leftNum = getGroupNumber(options.groups, left)
             let rightNum = 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(compare(left, right, options))))
             ) {
               context.report({
-                messageId: 'unexpectedClassesOrder',
+                messageId:
+                  leftNum !== rightNum
+                    ? 'unexpectedClassesGroupOrder'
+                    : 'unexpectedClassesOrder',
                 data: {
                   left: toSingleLine(left.name),
+                  leftGroup: left.group,
                   right: 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(options.groups, sortingNode)
-                    if (!(groupNum in accumulator)) {
-                      accumulator[groupNum] = [sortingNode]
-                    } else {
-                      accumulator[groupNum] = 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),
-                  )) {
-                    sortedNodes.push(...sortNodes(grouped[group], options))
+                  for (let groupNumber of Object.keys(
+                    nodesByNonIgnoredGroupNumber,
+                  ).sort((a, b) => Number(a) - Number(b))) {
+                    sortedNodes.push(
+                      ...sortNodes(
+                        nodesByNonIgnoredGroupNumber[Number(groupNumber)],
+                        options,
+                      ),
+                    )
+                  }
+                  for (let ignoredIndex of ignoredNodeIndices) {
+                    sortedNodes.splice(ignoredIndex, 0, nodes[ignoredIndex])
                   }
                   return makeFixes(fixer, nodes, sortedNodes, sourceCode, {
                     partitionComment: options.partitionByComment,

package/dist/rules/sort-enums.js

@@ -5,6 +5,7 @@ const getCommentBefore = require('../utils/get-comment-before.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')
@@ -39,6 +40,15 @@ const sortEnums = createEslintRule.createEslintRule({
               'Controls whether sorting should be case-sensitive or not.',
             type: 'boolean',
           },
+          sortByValue: {
+            description: 'Compare enum values instead of names.',
+            type: 'boolean',
+          },
+          forceNumericSort: {
+            description:
+              'Will always sort numeric enums by their value regardless of the sort type specified.',
+            type: 'boolean',
+          },
           partitionByComment: {
             description:
               'Allows you to use comments to separate the class members into logical groups.',
@@ -70,7 +80,9 @@ const sortEnums = createEslintRule.createEslintRule({
       type: 'alphabetical',
       order: 'asc',
       ignoreCase: true,
+      sortByValue: false,
       partitionByComment: false,
+      forceNumericSort: false,
     },
   ],
   create: context => ({
@@ -85,19 +97,46 @@ const sortEnums = createEslintRule.createEslintRule({
           []
         )
       }
+      let members = getMembers(node)
       if (
-        getMembers(node).length > 1 &&
-        getMembers(node).every(({ initializer }) => initializer)
+        members.length > 1 &&
+        members.every(({ initializer }) => initializer)
       ) {
-        let options = complete.complete(context.options.at(0), {
+        let settings = getSettings.getSettings(context.settings)
+        let options = complete.complete(context.options.at(0), settings, {
           partitionByComment: false,
           type: 'alphabetical',
           ignoreCase: true,
           order: 'asc',
+          sortByValue: false,
+          forceNumericSort: false,
         })
         let sourceCode = getSourceCode.getSourceCode(context)
         let partitionComment = options.partitionByComment
-        let formattedMembers = getMembers(node).reduce(
+        let extractDependencies = (expression, enumName) => {
+          let dependencies = []
+          let checkNode = nodeValue => {
+            if (
+              nodeValue.type === 'MemberExpression' &&
+              nodeValue.object.type === 'Identifier' &&
+              nodeValue.object.name === enumName &&
+              nodeValue.property.type === 'Identifier'
+            ) {
+              dependencies.push(nodeValue.property.name)
+            } else if (nodeValue.type === 'Identifier') {
+              dependencies.push(nodeValue.name)
+            }
+            if ('left' in nodeValue) {
+              checkNode(nodeValue.left)
+            }
+            if ('right' in nodeValue) {
+              checkNode(nodeValue.right)
+            }
+          }
+          checkNode(expression)
+          return dependencies
+        }
+        let formattedMembers = members.reduce(
           (accumulator, member) => {
             let comment = getCommentBefore.getCommentBefore(member, sourceCode)
             if (
@@ -114,9 +153,17 @@ const sortEnums = createEslintRule.createEslintRule({
               member.id.type === 'Literal'
                 ? `${member.id.value}`
                 : `${sourceCode.text.slice(...member.id.range)}`
+            let dependencies
+            if (member.initializer) {
+              dependencies = extractDependencies(
+                member.initializer,
+                node.id.name,
+              )
+            }
             let sortingNode = {
               size: rangeToDiff.rangeToDiff(member.range),
               node: member,
+              dependencies,
               name,
             }
             accumulator.at(-1).push(sortingNode)
@@ -124,9 +171,49 @@ const sortEnums = createEslintRule.createEslintRule({
           },
           [[]],
         )
+        let isNumericEnum = members.every(member => {
+          var _a
+          return (
+            ((_a = member.initializer) == null ? void 0 : _a.type) ===
+              'Literal' && typeof member.initializer.value === 'number'
+          )
+        })
+        let compareOptions = {
+          // If the enum is numeric, and we sort by value, always use the `natural` sort type, which will correctly sort them.
+          type:
+            isNumericEnum && (options.forceNumericSort || options.sortByValue)
+              ? 'natural'
+              : options.type,
+          order: options.order,
+          ignoreCase: options.ignoreCase,
+          // Get the enum value rather than the name if needed
+          nodeValueGetter:
+            options.sortByValue || (isNumericEnum && options.forceNumericSort)
+              ? sortingNode => {
+                  var _a, _b
+                  if (
+                    sortingNode.node.type === 'TSEnumMember' &&
+                    ((_a = sortingNode.node.initializer) == null
+                      ? void 0
+                      : _a.type) === 'Literal'
+                  ) {
+                    return (
+                      ((_b = sortingNode.node.initializer.value) == null
+                        ? void 0
+                        : _b.toString()) ?? ''
+                    )
+                  }
+                  return ''
+                }
+              : void 0,
+        }
         for (let nodes of formattedMembers) {
           pairwise.pairwise(nodes, (left, right) => {
-            if (isPositive.isPositive(compare.compare(left, right, options))) {
+            if (
+              isPositive.isPositive(
+                compare.compare(left, right, compareOptions),
+              )
+            ) {
               context.report({
                 messageId: 'unexpectedEnumsOrder',
                 data: {
@@ -138,7 +225,7 @@ const sortEnums = createEslintRule.createEslintRule({
                   makeFixes.makeFixes(
                     fixer,
                     nodes,
-                    sortNodes.sortNodes(nodes, options),
+                    sortNodes.sortNodes(nodes, compareOptions),
                     sourceCode,
                     { partitionComment },
                   ),

package/dist/rules/sort-enums.mjs

@@ -4,6 +4,7 @@ import { getCommentBefore } from '../utils/get-comment-before.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'
@@ -38,6 +39,15 @@ const sortEnums = createEslintRule({
               'Controls whether sorting should be case-sensitive or not.',
             type: 'boolean',
           },
+          sortByValue: {
+            description: 'Compare enum values instead of names.',
+            type: 'boolean',
+          },
+          forceNumericSort: {
+            description:
+              'Will always sort numeric enums by their value regardless of the sort type specified.',
+            type: 'boolean',
+          },
           partitionByComment: {
             description:
               'Allows you to use comments to separate the class members into logical groups.',
@@ -69,7 +79,9 @@ const sortEnums = createEslintRule({
       type: 'alphabetical',
       order: 'asc',
       ignoreCase: true,
+      sortByValue: false,
       partitionByComment: false,
+      forceNumericSort: false,
     },
   ],
   create: context => ({
@@ -84,19 +96,46 @@ const sortEnums = createEslintRule({
           []
         )
       }
+      let members = getMembers(node)
       if (
-        getMembers(node).length > 1 &&
-        getMembers(node).every(({ initializer }) => initializer)
+        members.length > 1 &&
+        members.every(({ initializer }) => initializer)
       ) {
-        let options = complete(context.options.at(0), {
+        let settings = getSettings(context.settings)
+        let options = complete(context.options.at(0), settings, {
           partitionByComment: false,
           type: 'alphabetical',
           ignoreCase: true,
           order: 'asc',
+          sortByValue: false,
+          forceNumericSort: false,
         })
         let sourceCode = getSourceCode(context)
         let partitionComment = options.partitionByComment
-        let formattedMembers = getMembers(node).reduce(
+        let extractDependencies = (expression, enumName) => {
+          let dependencies = []
+          let checkNode = nodeValue => {
+            if (
+              nodeValue.type === 'MemberExpression' &&
+              nodeValue.object.type === 'Identifier' &&
+              nodeValue.object.name === enumName &&
+              nodeValue.property.type === 'Identifier'
+            ) {
+              dependencies.push(nodeValue.property.name)
+            } else if (nodeValue.type === 'Identifier') {
+              dependencies.push(nodeValue.name)
+            }
+            if ('left' in nodeValue) {
+              checkNode(nodeValue.left)
+            }
+            if ('right' in nodeValue) {
+              checkNode(nodeValue.right)
+            }
+          }
+          checkNode(expression)
+          return dependencies
+        }
+        let formattedMembers = members.reduce(
           (accumulator, member) => {
             let comment = getCommentBefore(member, sourceCode)
             if (
@@ -110,9 +149,17 @@ const sortEnums = createEslintRule({
               member.id.type === 'Literal'
                 ? `${member.id.value}`
                 : `${sourceCode.text.slice(...member.id.range)}`
+            let dependencies
+            if (member.initializer) {
+              dependencies = extractDependencies(
+                member.initializer,
+                node.id.name,
+              )
+            }
             let sortingNode = {
               size: rangeToDiff(member.range),
               node: member,
+              dependencies,
               name,
             }
             accumulator.at(-1).push(sortingNode)
@@ -120,9 +167,45 @@ const sortEnums = createEslintRule({
           },
           [[]],
         )
+        let isNumericEnum = members.every(member => {
+          var _a
+          return (
+            ((_a = member.initializer) == null ? void 0 : _a.type) ===
+              'Literal' && typeof member.initializer.value === 'number'
+          )
+        })
+        let compareOptions = {
+          // If the enum is numeric, and we sort by value, always use the `natural` sort type, which will correctly sort them.
+          type:
+            isNumericEnum && (options.forceNumericSort || options.sortByValue)
+              ? 'natural'
+              : options.type,
+          order: options.order,
+          ignoreCase: options.ignoreCase,
+          // Get the enum value rather than the name if needed
+          nodeValueGetter:
+            options.sortByValue || (isNumericEnum && options.forceNumericSort)
+              ? sortingNode => {
+                  var _a, _b
+                  if (
+                    sortingNode.node.type === 'TSEnumMember' &&
+                    ((_a = sortingNode.node.initializer) == null
+                      ? void 0
+                      : _a.type) === 'Literal'
+                  ) {
+                    return (
+                      ((_b = sortingNode.node.initializer.value) == null
+                        ? void 0
+                        : _b.toString()) ?? ''
+                    )
+                  }
+                  return ''
+                }
+              : void 0,
+        }
         for (let nodes of formattedMembers) {
           pairwise(nodes, (left, right) => {
-            if (isPositive(compare(left, right, options))) {
+            if (isPositive(compare(left, right, compareOptions))) {
               context.report({
                 messageId: 'unexpectedEnumsOrder',
                 data: {
@@ -134,7 +217,7 @@ const sortEnums = createEslintRule({
                   makeFixes(
                     fixer,
                     nodes,
-                    sortNodes(nodes, options),
+                    sortNodes(nodes, compareOptions),
                     sourceCode,
                     { partitionComment },
                   ),

package/dist/rules/sort-exports.js

@@ -2,6 +2,7 @@
 const createEslintRule = require('../utils/create-eslint-rule.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 sortNodes = require('../utils/sort-nodes.js')
 const makeFixes = require('../utils/make-fixes.js')
@@ -52,7 +53,8 @@ const sortExports = createEslintRule.createEslintRule({
     },
   ],
   create: context => {
-    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,
       order: 'asc',