eslint-plugin-perfectionist 3.3.0 → 3.5.0

package/dist/rules/sort-classes.mjs

@@ -1,7 +1,15 @@
 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'
@@ -10,13 +18,11 @@ 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: {
@@ -82,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,
@@ -114,9 +162,9 @@ const sortClasses = createEslintRule({
       ignoreCase: true,
       partitionByComment: false,
       groups: [
-        'static-block',
         'index-signature',
         'static-property',
+        'static-block',
         ['protected-property', 'protected-accessor-property'],
         ['private-property', 'private-accessor-property'],
         ['property', 'accessor-property'],
@@ -128,18 +176,19 @@ 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: [
-            'static-block',
             'index-signature',
             'static-property',
+            'static-block',
             ['protected-property', 'protected-accessor-property'],
             ['private-property', 'private-accessor-property'],
             ['property', 'accessor-property'],
@@ -154,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)
@@ -182,9 +288,21 @@ 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)
+            }
+            if ('expressions' in nodeValue) {
+              nodeValue.expressions.forEach(traverseNode)
+            }
           }
           let traverseNode = nodeValue => {
             if (Array.isArray(nodeValue)) {
@@ -199,7 +317,7 @@ const sortClasses = createEslintRule({
         let overloadSignatureGroups = getOverloadSignatureGroups(node.body)
         let formattedNodes = node.body.reduce(
           (accumulator, member) => {
-            var _a, _b, _c, _d
+            var _a2, _b, _c, _d
             let comment = getCommentBefore(member, sourceCode)
             if (
               options.partitionByComment &&
@@ -218,9 +336,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') {
@@ -231,8 +349,21 @@ const sortClasses = createEslintRule({
             }
             let isPrivateHash =
               'key' in member && member.key.type === 'PrivateIdentifier'
-            let decorated =
-              'decorators' in member && member.decorators.length > 0
+            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 (
@@ -281,6 +412,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'
@@ -334,15 +466,22 @@ const sortClasses = createEslintRule({
               if (member.optional) {
                 modifiers.push('optional')
               }
-              if (
+              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,
@@ -350,11 +489,27 @@ 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 =>
@@ -370,6 +525,10 @@ const sortClasses = createEslintRule({
               node: member,
               dependencies,
               name,
+              dependencyName: getDependencyName(
+                name,
+                modifiers.includes('static'),
+              ),
             }
             accumulator.at(-1).push(value)
             return accumulator
@@ -377,18 +536,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)
             let isLeftOrRightIgnored =
               leftNum === options.groups.length ||
               rightNum === options.groups.length
-            if (
-              !isLeftOrRightIgnored &&
-              (leftNum > rightNum ||
-                (leftNum === rightNum &&
-                  isPositive(compare(left, right, options))))
-            ) {
+            let indexOfLeft = sortedNodes.indexOf(left)
+            let indexOfRight = sortedNodes.indexOf(right)
+            if (!isLeftOrRightIgnored && indexOfLeft > indexOfRight) {
               context.report({
                 messageId:
                   leftNum !== rightNum
@@ -401,37 +591,10 @@ const sortClasses = createEslintRule({
                   rightGroup: right.group,
                 },
                 node: right.node,
-                fix: fixer => {
-                  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))) {
-                    sortedNodes.push(
-                      ...sortNodes(
-                        nodesByNonIgnoredGroupNumber[Number(groupNumber)],
-                        options,
-                      ),
-                    )
-                  }
-                  for (let ignoredIndex of ignoredNodeIndices) {
-                    sortedNodes.splice(ignoredIndex, 0, nodes[ignoredIndex])
-                  }
-                  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,
+}

package/dist/rules/sort-enums.js

@@ -1,4 +1,5 @@
 'use strict'
+const sortNodesByDependencies = require('../utils/sort-nodes-by-dependencies.js')
 const isPartitionComment = require('../utils/is-partition-comment.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const getCommentBefore = require('../utils/get-comment-before.js')
@@ -6,12 +7,10 @@ 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')
 const complete = require('../utils/complete.js')
 const pairwise = require('../utils/pairwise.js')
-const compare = require('../utils/compare.js')
 const sortEnums = createEslintRule.createEslintRule({
   name: 'sort-enums',
   meta: {
@@ -153,7 +152,7 @@ const sortEnums = createEslintRule.createEslintRule({
               member.id.type === 'Literal'
                 ? `${member.id.value}`
                 : `${sourceCode.text.slice(...member.id.range)}`
-            let dependencies
+            let dependencies = []
             if (member.initializer) {
               dependencies = extractDependencies(
                 member.initializer,
@@ -208,12 +207,13 @@ const sortEnums = createEslintRule.createEslintRule({
               : void 0,
         }
         for (let nodes of formattedMembers) {
+          let sortedNodes = sortNodesByDependencies.sortNodesByDependencies(
+            sortNodes.sortNodes(nodes, compareOptions),
+          )
           pairwise.pairwise(nodes, (left, right) => {
-            if (
-              isPositive.isPositive(
-                compare.compare(left, right, compareOptions),
-              )
-            ) {
+            let indexOfLeft = sortedNodes.indexOf(left)
+            let indexOfRight = sortedNodes.indexOf(right)
+            if (indexOfLeft > indexOfRight) {
               context.report({
                 messageId: 'unexpectedEnumsOrder',
                 data: {
@@ -222,13 +222,9 @@ const sortEnums = createEslintRule.createEslintRule({
                 },
                 node: right.node,
                 fix: fixer =>
-                  makeFixes.makeFixes(
-                    fixer,
-                    nodes,
-                    sortNodes.sortNodes(nodes, compareOptions),
-                    sourceCode,
-                    { partitionComment },
-                  ),
+                  makeFixes.makeFixes(fixer, nodes, sortedNodes, sourceCode, {
+                    partitionComment,
+                  }),
               })
             }
           })