eslint-plugin-perfectionist 3.2.0 → 3.4.0

package/dist/rules/sort-classes.js

@@ -1,20 +1,20 @@
 'use strict'
+const sortClassesUtils = require('./sort-classes-utils.js')
+const sortClasses_types = require('./sort-classes.types.js')
+const sortNodesByDependencies = require('../utils/sort-nodes-by-dependencies.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')
-const sortClassesUtils = require('./sort-classes-utils.js')
 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')
 const makeFixes = require('../utils/make-fixes.js')
 const complete = require('../utils/complete.js')
 const pairwise = require('../utils/pairwise.js')
-const compare = require('../utils/compare.js')
 const sortClasses = createEslintRule.createEslintRule({
   name: 'sort-classes',
   meta: {
@@ -80,20 +80,62 @@ const sortClasses = createEslintRule.createEslintRule({
           },
           customGroups: {
             description: 'Specifies custom groups.',
-            type: 'object',
-            additionalProperties: {
-              oneOf: [
-                {
-                  type: 'string',
+            oneOf: [
+              {
+                type: 'object',
+                additionalProperties: {
+                  oneOf: [
+                    {
+                      type: 'string',
+                    },
+                    {
+                      type: 'array',
+                      items: {
+                        type: 'string',
+                      },
+                    },
+                  ],
                 },
-                {
-                  type: 'array',
-                  items: {
-                    type: 'string',
-                  },
+              },
+              {
+                type: 'array',
+                items: {
+                  description: 'Advanced custom groups.',
+                  oneOf: [
+                    {
+                      description: 'Custom group block.',
+                      type: 'object',
+                      additionalProperties: false,
+                      properties: {
+                        ...sortClasses_types.customGroupNameJsonSchema,
+                        ...sortClasses_types.customGroupSortJsonSchema,
+                        anyOf: {
+                          type: 'array',
+                          items: {
+                            description: 'Custom group.',
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                              ...sortClasses_types.singleCustomGroupJsonSchema,
+                            },
+                          },
+                        },
+                      },
+                    },
+                    {
+                      description: 'Custom group.',
+                      type: 'object',
+                      additionalProperties: false,
+                      properties: {
+                        ...sortClasses_types.customGroupNameJsonSchema,
+                        ...sortClasses_types.customGroupSortJsonSchema,
+                        ...sortClasses_types.singleCustomGroupJsonSchema,
+                      },
+                    },
+                  ],
                 },
-              ],
-            },
+              },
+            ],
           },
         },
         additionalProperties: false,
@@ -114,9 +156,10 @@ const sortClasses = createEslintRule.createEslintRule({
       groups: [
         'index-signature',
         'static-property',
-        'protected-property',
-        'private-property',
-        'property',
+        'static-block',
+        ['protected-property', 'protected-accessor-property'],
+        ['private-property', 'private-accessor-property'],
+        ['property', 'accessor-property'],
         'constructor',
         'static-method',
         'protected-method',
@@ -125,20 +168,22 @@ const sortClasses = createEslintRule.createEslintRule({
         ['get-method', 'set-method'],
         'unknown',
       ],
-      customGroups: {},
+      customGroups: [],
     },
   ],
   create: context => ({
     ClassBody: node => {
+      var _a
       if (node.body.length > 1) {
         let settings = getSettings.getSettings(context.settings)
         let options = complete.complete(context.options.at(0), settings, {
           groups: [
             'index-signature',
             'static-property',
-            'protected-property',
-            'private-property',
-            'property',
+            'static-block',
+            ['protected-property', 'protected-accessor-property'],
+            ['private-property', 'private-accessor-property'],
+            ['property', 'accessor-property'],
             'constructor',
             'static-method',
             'protected-method',
@@ -150,19 +195,76 @@ const sortClasses = createEslintRule.createEslintRule({
           partitionByComment: false,
           type: 'alphabetical',
           ignoreCase: true,
-          customGroups: {},
+          customGroups: [],
           order: 'asc',
         })
         let sourceCode = getSourceCode.getSourceCode(context)
-        let extractDependencies = expression => {
+        let className = (_a = node.parent.id) == null ? void 0 : _a.name
+        let getDependencyName = (nodeName, isStatic) =>
+          `${isStatic ? 'static ' : ''}${nodeName}`
+        let classMethodsDependencyNames = new Set(
+          node.body
+            .map(member => {
+              if (
+                (member.type === 'MethodDefinition' ||
+                  member.type === 'TSAbstractMethodDefinition') &&
+                'name' in member.key
+              ) {
+                return getDependencyName(member.key.name, member.static)
+              }
+              return null
+            })
+            .filter(m => m !== null),
+        )
+        let extractDependencies = (expression, isMemberStatic) => {
           let dependencies = []
           let checkNode = nodeValue => {
+            if (
+              nodeValue.type === 'ArrowFunctionExpression' ||
+              nodeValue.type === 'FunctionExpression'
+            ) {
+              return
+            }
             if (
               nodeValue.type === 'MemberExpression' &&
-              nodeValue.object.type === 'ThisExpression' &&
+              (nodeValue.object.type === 'ThisExpression' ||
+                (nodeValue.object.type === 'Identifier' &&
+                  nodeValue.object.name === className)) &&
               nodeValue.property.type === 'Identifier'
             ) {
-              dependencies.push(nodeValue.property.name)
+              let isStaticDependency =
+                isMemberStatic || nodeValue.object.type === 'Identifier'
+              let dependencyName = getDependencyName(
+                nodeValue.property.name,
+                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)
@@ -178,9 +280,18 @@ const sortClasses = createEslintRule.createEslintRule({
                 .filter(currentNode => currentNode !== null)
                 .forEach(traverseNode)
             }
+            if ('argument' in nodeValue && nodeValue.argument) {
+              traverseNode(nodeValue.argument)
+            }
             if ('arguments' in nodeValue) {
               nodeValue.arguments.forEach(traverseNode)
             }
+            if ('declarations' in nodeValue) {
+              nodeValue.declarations.forEach(traverseNode)
+            }
+            if ('properties' in nodeValue) {
+              nodeValue.properties.forEach(traverseNode)
+            }
           }
           let traverseNode = nodeValue => {
             if (Array.isArray(nodeValue)) {
@@ -192,9 +303,11 @@ const sortClasses = createEslintRule.createEslintRule({
           traverseNode(expression)
           return dependencies
         }
+        let overloadSignatureGroups =
+          sortClassesUtils.getOverloadSignatureGroups(node.body)
         let formattedNodes = node.body.reduce(
           (accumulator, member) => {
-            var _a, _b, _c
+            var _a2, _b, _c, _d
             let comment = getCommentBefore.getCommentBefore(member, sourceCode)
             if (
               options.partitionByComment &&
@@ -215,9 +328,9 @@ const sortClasses = createEslintRule.createEslintRule({
             } else if (member.type === 'TSIndexSignature') {
               name = sourceCode.text.slice(
                 member.range.at(0),
-                ((_a = member.typeAnnotation) == null
+                ((_a2 = member.typeAnnotation) == null
                   ? void 0
-                  : _a.range.at(0)) ?? member.range.at(1),
+                  : _a2.range.at(0)) ?? member.range.at(1),
               )
             } else {
               if (member.key.type === 'Identifier') {
@@ -226,9 +339,23 @@ const sortClasses = createEslintRule.createEslintRule({
                 name = sourceCode.text.slice(...member.key.range)
               }
             }
-            let isPrivateName = name.startsWith('#')
-            let decorated =
-              'decorators' in member && member.decorators.length > 0
+            let isPrivateHash =
+              'key' in member && member.key.type === 'PrivateIdentifier'
+            let decorated = false
+            let decorators = []
+            if ('decorators' in member) {
+              decorated = member.decorators.length > 0
+              for (let decorator of member.decorators) {
+                if (decorator.expression.type === 'Identifier') {
+                  decorators.push(decorator.expression.name)
+                } else if (
+                  decorator.expression.type === 'CallExpression' &&
+                  decorator.expression.callee.type === 'Identifier'
+                ) {
+                  decorators.push(decorator.expression.callee.name)
+                }
+              }
+            }
             let modifiers = []
             let selectors = []
             if (
@@ -249,11 +376,14 @@ const sortClasses = createEslintRule.createEslintRule({
               }
               if (member.accessibility === 'protected') {
                 modifiers.push('protected')
-              } else if (member.accessibility === 'private' || isPrivateName) {
+              } else if (member.accessibility === 'private' || isPrivateHash) {
                 modifiers.push('private')
               } else {
                 modifiers.push('public')
               }
+              if (member.optional) {
+                modifiers.push('optional')
+              }
               if (member.kind === 'constructor') {
                 selectors.push('constructor')
               }
@@ -274,6 +404,7 @@ const sortClasses = createEslintRule.createEslintRule({
               selectors.push('index-signature')
             } else if (member.type === 'StaticBlock') {
               selectors.push('static-block')
+              dependencies = extractDependencies(member, true)
             } else if (
               member.type === 'AccessorProperty' ||
               member.type === 'TSAbstractAccessorProperty'
@@ -292,7 +423,7 @@ const sortClasses = createEslintRule.createEslintRule({
               }
               if (member.accessibility === 'protected') {
                 modifiers.push('protected')
-              } else if (member.accessibility === 'private' || isPrivateName) {
+              } else if (member.accessibility === 'private' || isPrivateHash) {
                 modifiers.push('private')
               } else {
                 modifiers.push('public')
@@ -319,20 +450,30 @@ const sortClasses = createEslintRule.createEslintRule({
               }
               if (member.accessibility === 'protected') {
                 modifiers.push('protected')
-              } else if (member.accessibility === 'private' || isPrivateName) {
+              } else if (member.accessibility === 'private' || isPrivateHash) {
                 modifiers.push('private')
               } else {
                 modifiers.push('public')
               }
-              if (
+              if (member.optional) {
+                modifiers.push('optional')
+              }
+              let isFunctionProperty =
                 ((_b = member.value) == null ? void 0 : _b.type) ===
                   'ArrowFunctionExpression' ||
                 ((_c = member.value) == null ? void 0 : _c.type) ===
                   'FunctionExpression'
-              ) {
+              if (isFunctionProperty) {
                 selectors.push('function-property')
               }
               selectors.push('property')
+              if (
+                member.type === 'PropertyDefinition' &&
+                member.value &&
+                !isFunctionProperty
+              ) {
+                dependencies = extractDependencies(member.value, member.static)
+              }
             }
             for (let officialGroup of sortClassesUtils.generateOfficialGroups(
               modifiers,
@@ -340,18 +481,46 @@ const sortClasses = createEslintRule.createEslintRule({
             )) {
               defineGroup(officialGroup)
             }
-            setCustomGroups(options.customGroups, name, {
-              override: true,
-            })
-            if (member.type === 'PropertyDefinition' && member.value) {
-              dependencies = extractDependencies(member.value)
+            if (Array.isArray(options.customGroups)) {
+              for (let customGroup of options.customGroups) {
+                if (
+                  sortClassesUtils.customGroupMatches({
+                    customGroup,
+                    elementName: name,
+                    modifiers,
+                    selectors,
+                    decorators,
+                  })
+                ) {
+                  defineGroup(customGroup.groupName, true)
+                  if (getGroup() === customGroup.groupName) {
+                    break
+                  }
+                }
+              }
+            } else {
+              setCustomGroups(options.customGroups, name, {
+                override: true,
+              })
             }
+            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,
               name,
+              dependencyName: getDependencyName(
+                name,
+                modifiers.includes('static'),
+              ),
             }
             accumulator.at(-1).push(value)
             return accumulator
@@ -359,15 +528,56 @@ const sortClasses = createEslintRule.createEslintRule({
           [[]],
         )
         for (let nodes of formattedNodes) {
+          let nodesByNonIgnoredGroupNumber = {}
+          let ignoredNodeIndices = []
+          for (let [index, sortingNode] of nodes.entries()) {
+            let groupNum = getGroupNumber.getGroupNumber(
+              options.groups,
+              sortingNode,
+            )
+            if (groupNum === options.groups.length) {
+              ignoredNodeIndices.push(index)
+              continue
+            }
+            nodesByNonIgnoredGroupNumber[groupNum] =
+              nodesByNonIgnoredGroupNumber[groupNum] ?? []
+            nodesByNonIgnoredGroupNumber[groupNum].push(sortingNode)
+          }
+          let sortedNodes = []
+          for (let groupNumber of Object.keys(
+            nodesByNonIgnoredGroupNumber,
+          ).sort((a, b) => Number(a) - Number(b))) {
+            let compareOptions = sortClassesUtils.getCompareOptions(
+              options,
+              Number(groupNumber),
+            )
+            if (!compareOptions) {
+              sortedNodes.push(
+                ...nodesByNonIgnoredGroupNumber[Number(groupNumber)],
+              )
+            } else {
+              sortedNodes.push(
+                ...sortNodes.sortNodes(
+                  nodesByNonIgnoredGroupNumber[Number(groupNumber)],
+                  compareOptions,
+                ),
+              )
+            }
+          }
+          for (let ignoredIndex of ignoredNodeIndices) {
+            sortedNodes.splice(ignoredIndex, 0, nodes[ignoredIndex])
+          }
+          sortedNodes =
+            sortNodesByDependencies.sortNodesByDependencies(sortedNodes)
           pairwise.pairwise(nodes, (left, right) => {
             let leftNum = getGroupNumber.getGroupNumber(options.groups, left)
             let rightNum = getGroupNumber.getGroupNumber(options.groups, right)
-            if (
-              left.name !== right.name &&
-              (leftNum > rightNum ||
-                (leftNum === rightNum &&
-                  isPositive.isPositive(compare.compare(left, right, options))))
-            ) {
+            let isLeftOrRightIgnored =
+              leftNum === options.groups.length ||
+              rightNum === options.groups.length
+            let indexOfLeft = sortedNodes.indexOf(left)
+            let indexOfRight = sortedNodes.indexOf(right)
+            if (!isLeftOrRightIgnored && indexOfLeft > indexOfRight) {
               context.report({
                 messageId:
                   leftNum !== rightNum
@@ -380,40 +590,10 @@ const sortClasses = createEslintRule.createEslintRule({
                   rightGroup: right.group,
                 },
                 node: right.node,
-                fix: fixer => {
-                  let grouped = nodes.reduce((accumulator, sortingNode) => {
-                    let groupNum = getGroupNumber.getGroupNumber(
-                      options.groups,
-                      sortingNode,
-                    )
-                    if (!(groupNum in accumulator)) {
-                      accumulator[groupNum] = [sortingNode]
-                    } else {
-                      accumulator[groupNum] = sortNodes.sortNodes(
-                        [...accumulator[groupNum], sortingNode],
-                        options,
-                      )
-                    }
-                    return accumulator
-                  }, {})
-                  let sortedNodes = []
-                  for (let group of Object.keys(grouped).sort(
-                    (a, b) => Number(a) - Number(b),
-                  )) {
-                    sortedNodes.push(
-                      ...sortNodes.sortNodes(grouped[group], options),
-                    )
-                  }
-                  return makeFixes.makeFixes(
-                    fixer,
-                    nodes,
-                    sortedNodes,
-                    sourceCode,
-                    {
-                      partitionComment: options.partitionByComment,
-                    },
-                  )
-                },
+                fix: fixer =>
+                  makeFixes.makeFixes(fixer, nodes, sortedNodes, sourceCode, {
+                    partitionComment: options.partitionByComment,
+                  }),
               })
             }
           })