eslint-plugin-perfectionist 3.1.3 → 3.2.0

package/dist/index.d.ts

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,68 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+const cachedGroupsByModifiersAndSelectors = /* @__PURE__ */ new Map()
+const generateOfficialGroups = (modifiers, selectors) => {
+  let modifiersAndSelectorsKey = modifiers.join('&') + '/' + selectors.join('&')
+  let cachedValue = cachedGroupsByModifiersAndSelectors.get(
+    modifiersAndSelectorsKey,
+  )
+  if (cachedValue) {
+    return cachedValue
+  }
+  let allModifiersCombinations = []
+  for (let i = modifiers.length; i > 0; i--) {
+    allModifiersCombinations = [
+      ...allModifiersCombinations,
+      ...getCombinations(modifiers, i),
+    ]
+  }
+  let allModifiersCombinationPermutations = allModifiersCombinations.flatMap(
+    result => getPermutations(result),
+  )
+  let returnValue = []
+  for (let selector of selectors) {
+    returnValue = [
+      ...returnValue,
+      ...allModifiersCombinationPermutations.map(
+        modifiersCombinationPermutation =>
+          [...modifiersCombinationPermutation, selector].join('-'),
+      ),
+      selector,
+    ]
+  }
+  cachedGroupsByModifiersAndSelectors.set(modifiersAndSelectorsKey, returnValue)
+  return returnValue
+}
+const getCombinations = (array, n) => {
+  let result = []
+  let backtrack = (start, comb) => {
+    if (comb.length === n) {
+      result.push([...comb])
+      return
+    }
+    for (let i = start; i < array.length; i++) {
+      comb.push(array[i])
+      backtrack(i + 1, comb)
+      comb.pop()
+    }
+  }
+  backtrack(0, [])
+  return result
+}
+const getPermutations = elements => {
+  let result = []
+  let backtrack = first => {
+    if (first === elements.length) {
+      result.push([...elements])
+      return
+    }
+    for (let i = first; i < elements.length; i++) {
+      ;[elements[first], elements[i]] = [elements[i], elements[first]]
+      backtrack(first + 1)
+      ;[elements[first], elements[i]] = [elements[i], elements[first]]
+    }
+  }
+  backtrack(0)
+  return result
+}
+exports.generateOfficialGroups = generateOfficialGroups

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

@@ -0,0 +1,66 @@
+const cachedGroupsByModifiersAndSelectors = /* @__PURE__ */ new Map()
+const generateOfficialGroups = (modifiers, selectors) => {
+  let modifiersAndSelectorsKey = modifiers.join('&') + '/' + selectors.join('&')
+  let cachedValue = cachedGroupsByModifiersAndSelectors.get(
+    modifiersAndSelectorsKey,
+  )
+  if (cachedValue) {
+    return cachedValue
+  }
+  let allModifiersCombinations = []
+  for (let i = modifiers.length; i > 0; i--) {
+    allModifiersCombinations = [
+      ...allModifiersCombinations,
+      ...getCombinations(modifiers, i),
+    ]
+  }
+  let allModifiersCombinationPermutations = allModifiersCombinations.flatMap(
+    result => getPermutations(result),
+  )
+  let returnValue = []
+  for (let selector of selectors) {
+    returnValue = [
+      ...returnValue,
+      ...allModifiersCombinationPermutations.map(
+        modifiersCombinationPermutation =>
+          [...modifiersCombinationPermutation, selector].join('-'),
+      ),
+      selector,
+    ]
+  }
+  cachedGroupsByModifiersAndSelectors.set(modifiersAndSelectorsKey, returnValue)
+  return returnValue
+}
+const getCombinations = (array, n) => {
+  let result = []
+  let backtrack = (start, comb) => {
+    if (comb.length === n) {
+      result.push([...comb])
+      return
+    }
+    for (let i = start; i < array.length; i++) {
+      comb.push(array[i])
+      backtrack(i + 1, comb)
+      comb.pop()
+    }
+  }
+  backtrack(0, [])
+  return result
+}
+const getPermutations = elements => {
+  let result = []
+  let backtrack = first => {
+    if (first === elements.length) {
+      result.push([...elements])
+      return
+    }
+    for (let i = first; i < elements.length; i++) {
+      ;[elements[first], elements[i]] = [elements[i], elements[first]]
+      backtrack(first + 1)
+      ;[elements[first], elements[i]] = [elements[i], elements[first]]
+    }
+  }
+  backtrack(0)
+  return result
+}
+export { generateOfficialGroups }

package/dist/rules/sort-classes.js

@@ -2,10 +2,12 @@
 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')
@@ -98,6 +100,8 @@ const sortClasses = createEslintRule.createEslintRule({
       },
     ],
     messages: {
+      unexpectedClassesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedClassesOrder: 'Expected "{{right}}" to come before "{{left}}".',
     },
   },
@@ -127,7 +131,8 @@ const sortClasses = createEslintRule.createEslintRule({
   create: context => ({
     ClassBody: node => {
       if (node.body.length > 1) {
-        let options = complete.complete(context.options.at(0), {
+        let settings = getSettings.getSettings(context.settings)
+        let options = complete.complete(context.options.at(0), settings, {
           groups: [
             'index-signature',
             'static-property',
@@ -189,7 +194,7 @@ const sortClasses = createEslintRule.createEslintRule({
         }
         let formattedNodes = node.body.reduce(
           (accumulator, member) => {
-            var _a
+            var _a, _b, _c
             let comment = getCommentBefore.getCommentBefore(member, sourceCode)
             if (
               options.partitionByComment &&
@@ -221,80 +226,119 @@ const sortClasses = createEslintRule.createEslintRule({
                 name = sourceCode.text.slice(...member.key.range)
               }
             }
-            let isPrivate = name.startsWith('_') || name.startsWith('#')
+            let isPrivateName = name.startsWith('#')
             let decorated =
               'decorators' in member && member.decorators.length > 0
-            if (member.type === 'MethodDefinition') {
-              if (member.kind === 'constructor') {
-                defineGroup('constructor')
-              }
-              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')
+            let modifiers = []
+            let selectors = []
+            if (
+              member.type === 'MethodDefinition' ||
+              member.type === 'TSAbstractMethodDefinition'
+            ) {
+              if (member.static) {
+                modifiers.push('static')
               }
-              if (isPrivateMethod && isStaticMethod) {
-                defineGroup('static-private-method')
+              if (member.type === 'TSAbstractMethodDefinition') {
+                modifiers.push('abstract')
               }
-              if (isPrivateMethod) {
-                defineGroup('private-method')
+              if (decorated) {
+                modifiers.push('decorated')
               }
-              if (isStaticMethod) {
-                defineGroup('static-method')
+              if (member.override) {
+                modifiers.push('override')
               }
-              if (isProtectedMethod && isStaticMethod) {
-                defineGroup('static-protected-method')
+              if (member.accessibility === 'protected') {
+                modifiers.push('protected')
+              } else if (member.accessibility === 'private' || isPrivateName) {
+                modifiers.push('private')
+              } else {
+                modifiers.push('public')
               }
-              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 (decorated) {
-                if (member.accessibility === 'protected') {
-                  defineGroup('protected-decorated-accessor-property')
-                }
-                if (member.accessibility === 'private' || isPrivate) {
-                  defineGroup('private-decorated-accessor-property')
-                }
-                defineGroup('decorated-accessor-property')
+              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')
               }
-            } 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.accessibility === 'protected') {
-                defineGroup('protected-property')
+              if (member.override) {
+                modifiers.push('override')
               }
-              if (member.accessibility === 'private' || isPrivate) {
-                defineGroup('private-property')
+              if (member.accessibility === 'protected') {
+                modifiers.push('protected')
+              } else if (member.accessibility === 'private' || isPrivateName) {
+                modifiers.push('private')
+              } else {
+                modifiers.push('public')
               }
+              selectors.push('accessor-property')
+            } else {
               if (member.static) {
-                defineGroup('static-property')
+                modifiers.push('static')
+              }
+              if (member.declare) {
+                modifiers.push('declare')
+              }
+              if (member.type === 'TSAbstractPropertyDefinition') {
+                modifiers.push('abstract')
+              }
+              if (decorated) {
+                modifiers.push('decorated')
+              }
+              if (member.override) {
+                modifiers.push('override')
+              }
+              if (member.readonly) {
+                modifiers.push('readonly')
+              }
+              if (member.accessibility === 'protected') {
+                modifiers.push('protected')
+              } else if (member.accessibility === 'private' || isPrivateName) {
+                modifiers.push('private')
+              } else {
+                modifiers.push('public')
               }
-              defineGroup('property')
+              if (
+                ((_b = member.value) == null ? void 0 : _b.type) ===
+                  'ArrowFunctionExpression' ||
+                ((_c = member.value) == null ? void 0 : _c.type) ===
+                  'FunctionExpression'
+              ) {
+                selectors.push('function-property')
+              }
+              selectors.push('property')
+            }
+            for (let officialGroup of sortClassesUtils.generateOfficialGroups(
+              modifiers,
+              selectors,
+            )) {
+              defineGroup(officialGroup)
             }
             setCustomGroups(options.customGroups, name, {
               override: true,
@@ -325,10 +369,15 @@ const sortClasses = createEslintRule.createEslintRule({
                   isPositive.isPositive(compare.compare(left, right, options))))
             ) {
               context.report({
-                messageId: 'unexpectedClassesOrder',
+                messageId:
+                  leftNum !== rightNum
+                    ? 'unexpectedClassesGroupOrder'
+                    : 'unexpectedClassesOrder',
                 data: {
                   left: toSingleLine.toSingleLine(left.name),
+                  leftGroup: left.group,
                   right: toSingleLine.toSingleLine(right.name),
+                  rightGroup: right.group,
                 },
                 node: right.node,
                 fix: fixer => {