eslint-plugin-perfectionist 3.2.0 → 3.4.0

package/dist/rules/sort-classes.mjs

@@ -1,19 +1,28 @@
+import {
+  getOverloadSignatureGroups,
+  generateOfficialGroups,
+  customGroupMatches,
+  getCompareOptions,
+} from './sort-classes-utils.mjs'
+import {
+  customGroupNameJsonSchema,
+  customGroupSortJsonSchema,
+  singleCustomGroupJsonSchema,
+} from './sort-classes.types.mjs'
+import { sortNodesByDependencies } from '../utils/sort-nodes-by-dependencies.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'
-import { generateOfficialGroups } from './sort-classes-utils.mjs'
 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'
 import { makeFixes } from '../utils/make-fixes.mjs'
 import { complete } from '../utils/complete.mjs'
 import { pairwise } from '../utils/pairwise.mjs'
-import { compare } from '../utils/compare.mjs'
 const sortClasses = createEslintRule({
   name: 'sort-classes',
   meta: {
@@ -79,20 +88,62 @@ const sortClasses = 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: {
+                        ...customGroupNameJsonSchema,
+                        ...customGroupSortJsonSchema,
+                        anyOf: {
+                          type: 'array',
+                          items: {
+                            description: 'Custom group.',
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                              ...singleCustomGroupJsonSchema,
+                            },
+                          },
+                        },
+                      },
+                    },
+                    {
+                      description: 'Custom group.',
+                      type: 'object',
+                      additionalProperties: false,
+                      properties: {
+                        ...customGroupNameJsonSchema,
+                        ...customGroupSortJsonSchema,
+                        ...singleCustomGroupJsonSchema,
+                      },
+                    },
+                  ],
                 },
-              ],
-            },
+              },
+            ],
           },
         },
         additionalProperties: false,
@@ -113,9 +164,10 @@ const sortClasses = 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',
@@ -124,20 +176,22 @@ const sortClasses = createEslintRule({
         ['get-method', 'set-method'],
         'unknown',
       ],
-      customGroups: {},
+      customGroups: [],
     },
   ],
   create: context => ({
     ClassBody: node => {
+      var _a
       if (node.body.length > 1) {
         let settings = getSettings(context.settings)
         let options = 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',
@@ -149,19 +203,76 @@ const sortClasses = createEslintRule({
           partitionByComment: false,
           type: 'alphabetical',
           ignoreCase: true,
-          customGroups: {},
+          customGroups: [],
           order: 'asc',
         })
         let sourceCode = 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)
@@ -177,9 +288,18 @@ const sortClasses = 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)) {
@@ -191,9 +311,10 @@ const sortClasses = createEslintRule({
           traverseNode(expression)
           return dependencies
         }
+        let overloadSignatureGroups = getOverloadSignatureGroups(node.body)
         let formattedNodes = node.body.reduce(
           (accumulator, member) => {
-            var _a, _b, _c
+            var _a2, _b, _c, _d
             let comment = getCommentBefore(member, sourceCode)
             if (
               options.partitionByComment &&
@@ -212,9 +333,9 @@ const sortClasses = 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') {
@@ -223,9 +344,23 @@ const sortClasses = 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 (
@@ -246,11 +381,14 @@ const sortClasses = 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')
               }
@@ -271,6 +409,7 @@ const sortClasses = 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'
@@ -289,7 +428,7 @@ const sortClasses = 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')
@@ -316,20 +455,30 @@ const sortClasses = 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 generateOfficialGroups(
               modifiers,
@@ -337,18 +486,46 @@ const sortClasses = 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 (
+                  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(member.range),
+              size: overloadSignatureGroupMember
+                ? rangeToDiff(overloadSignatureGroupMember.range)
+                : rangeToDiff(member.range),
               group: getGroup(),
               node: member,
               dependencies,
               name,
+              dependencyName: getDependencyName(
+                name,
+                modifiers.includes('static'),
+              ),
             }
             accumulator.at(-1).push(value)
             return accumulator
@@ -356,15 +533,49 @@ const sortClasses = createEslintRule({
           [[]],
         )
         for (let nodes of formattedNodes) {
+          let nodesByNonIgnoredGroupNumber = {}
+          let ignoredNodeIndices = []
+          for (let [index, sortingNode] of nodes.entries()) {
+            let groupNum = 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 = getCompareOptions(options, Number(groupNumber))
+            if (!compareOptions) {
+              sortedNodes.push(
+                ...nodesByNonIgnoredGroupNumber[Number(groupNumber)],
+              )
+            } else {
+              sortedNodes.push(
+                ...sortNodes(
+                  nodesByNonIgnoredGroupNumber[Number(groupNumber)],
+                  compareOptions,
+                ),
+              )
+            }
+          }
+          for (let ignoredIndex of ignoredNodeIndices) {
+            sortedNodes.splice(ignoredIndex, 0, nodes[ignoredIndex])
+          }
+          sortedNodes = sortNodesByDependencies(sortedNodes)
           pairwise(nodes, (left, right) => {
             let leftNum = getGroupNumber(options.groups, left)
             let rightNum = getGroupNumber(options.groups, right)
-            if (
-              left.name !== right.name &&
-              (leftNum > rightNum ||
-                (leftNum === rightNum &&
-                  isPositive(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
@@ -377,29 +588,10 @@ const sortClasses = createEslintRule({
                   rightGroup: right.group,
                 },
                 node: right.node,
-                fix: fixer => {
-                  let grouped = nodes.reduce((accumulator, sortingNode) => {
-                    let groupNum = getGroupNumber(options.groups, sortingNode)
-                    if (!(groupNum in accumulator)) {
-                      accumulator[groupNum] = [sortingNode]
-                    } else {
-                      accumulator[groupNum] = 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(grouped[group], options))
-                  }
-                  return makeFixes(fixer, nodes, sortedNodes, sourceCode, {
+                fix: fixer =>
+                  makeFixes(fixer, nodes, sortedNodes, sourceCode, {
                     partitionComment: options.partitionByComment,
-                  })
-                },
+                  }),
               })
             }
           })

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

@@ -0,0 +1,71 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+const allSelectors = [
+  'accessor-property',
+  'index-signature',
+  'constructor',
+  'static-block',
+  'get-method',
+  'set-method',
+  'function-property',
+  'property',
+  'method',
+]
+const allModifiers = [
+  'protected',
+  'private',
+  'public',
+  'static',
+  'abstract',
+  'override',
+  'readonly',
+  'decorated',
+  'declare',
+  'optional',
+]
+const customGroupSortJsonSchema = {
+  type: {
+    description: 'Custom group sort type.',
+    type: 'string',
+    enum: ['alphabetical', 'line-length', 'natural', 'unsorted'],
+  },
+  order: {
+    description: 'Custom group sort order.',
+    type: 'string',
+    enum: ['desc', 'asc'],
+  },
+}
+const customGroupNameJsonSchema = {
+  groupName: {
+    description: 'Custom group name.',
+    type: 'string',
+  },
+}
+const singleCustomGroupJsonSchema = {
+  selector: {
+    description: 'Selector filter.',
+    type: 'string',
+    enum: allSelectors,
+  },
+  modifiers: {
+    description: 'Modifier filters.',
+    type: 'array',
+    items: {
+      type: 'string',
+      enum: allModifiers,
+    },
+  },
+  elementNamePattern: {
+    description: 'Element name pattern filter.',
+    type: 'string',
+  },
+  decoratorNamePattern: {
+    description: 'Decorator name pattern filter.',
+    type: 'string',
+  },
+}
+exports.allModifiers = allModifiers
+exports.allSelectors = allSelectors
+exports.customGroupNameJsonSchema = customGroupNameJsonSchema
+exports.customGroupSortJsonSchema = customGroupSortJsonSchema
+exports.singleCustomGroupJsonSchema = singleCustomGroupJsonSchema

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

@@ -0,0 +1,71 @@
+const allSelectors = [
+  'accessor-property',
+  'index-signature',
+  'constructor',
+  'static-block',
+  'get-method',
+  'set-method',
+  'function-property',
+  'property',
+  'method',
+]
+const allModifiers = [
+  'protected',
+  'private',
+  'public',
+  'static',
+  'abstract',
+  'override',
+  'readonly',
+  'decorated',
+  'declare',
+  'optional',
+]
+const customGroupSortJsonSchema = {
+  type: {
+    description: 'Custom group sort type.',
+    type: 'string',
+    enum: ['alphabetical', 'line-length', 'natural', 'unsorted'],
+  },
+  order: {
+    description: 'Custom group sort order.',
+    type: 'string',
+    enum: ['desc', 'asc'],
+  },
+}
+const customGroupNameJsonSchema = {
+  groupName: {
+    description: 'Custom group name.',
+    type: 'string',
+  },
+}
+const singleCustomGroupJsonSchema = {
+  selector: {
+    description: 'Selector filter.',
+    type: 'string',
+    enum: allSelectors,
+  },
+  modifiers: {
+    description: 'Modifier filters.',
+    type: 'array',
+    items: {
+      type: 'string',
+      enum: allModifiers,
+    },
+  },
+  elementNamePattern: {
+    description: 'Element name pattern filter.',
+    type: 'string',
+  },
+  decoratorNamePattern: {
+    description: 'Decorator name pattern filter.',
+    type: 'string',
+  },
+}
+export {
+  allModifiers,
+  allSelectors,
+  customGroupNameJsonSchema,
+  customGroupSortJsonSchema,
+  singleCustomGroupJsonSchema,
+}