eslint-plugin-perfectionist 3.5.0 → 3.6.0

package/dist/index.d.ts

@@ -120,7 +120,8 @@ declare const _default: {
       RuleListener
     >
     'sort-intersection-types': RuleModule<
-      'unexpectedIntersectionTypesOrder',
+      | 'unexpectedIntersectionTypesGroupOrder'
+      | 'unexpectedIntersectionTypesOrder',
       [
         Partial<{
           type: 'alphabetical' | 'line-length' | 'natural'
@@ -164,7 +165,8 @@ declare const _default: {
       RuleListener
     >
     'sort-svelte-attributes': RuleModule<
-      'unexpectedSvelteAttributesOrder',
+      | 'unexpectedSvelteAttributesGroupOrder'
+      | 'unexpectedSvelteAttributesOrder',
       [
         Partial<{
           customGroups: {
@@ -180,7 +182,7 @@ declare const _default: {
       RuleListener
     >
     'sort-astro-attributes': RuleModule<
-      'unexpectedAstroAttributesOrder',
+      'unexpectedAstroAttributesGroupOrder' | 'unexpectedAstroAttributesOrder',
       [
         Partial<{
           customGroups: {
@@ -196,7 +198,7 @@ declare const _default: {
       RuleListener
     >
     'sort-vue-attributes': RuleModule<
-      'unexpectedVueAttributesOrder',
+      'unexpectedVueAttributesGroupOrder' | 'unexpectedVueAttributesOrder',
       [
         Partial<{
           customGroups: {
@@ -245,7 +247,7 @@ declare const _default: {
       RuleListener
     >
     'sort-object-types': RuleModule<
-      'unexpectedObjectTypesOrder',
+      'unexpectedObjectTypesGroupOrder' | 'unexpectedObjectTypesOrder',
       [
         Partial<{
           groupKind: 'required-first' | 'optional-first' | 'mixed'
@@ -263,7 +265,7 @@ declare const _default: {
       RuleListener
     >
     'sort-union-types': RuleModule<
-      'unexpectedUnionTypesOrder',
+      'unexpectedUnionTypesGroupOrder' | 'unexpectedUnionTypesOrder',
       [
         Partial<{
           type: 'alphabetical' | 'line-length' | 'natural'
@@ -319,7 +321,8 @@ declare const _default: {
       RuleListener
     >
     'sort-interfaces': RuleModule<
-      'unexpectedInterfacePropertiesOrder',
+      | 'unexpectedInterfacePropertiesGroupOrder'
+      | 'unexpectedInterfacePropertiesOrder',
       [
         Partial<{
           groupKind: 'optional-first' | 'required-first' | 'mixed'
@@ -338,7 +341,7 @@ declare const _default: {
       RuleListener
     >
     'sort-jsx-props': RuleModule<
-      'unexpectedJSXPropsOrder',
+      'unexpectedJSXPropsGroupOrder' | 'unexpectedJSXPropsOrder',
       [
         Partial<{
           customGroups: {
@@ -362,6 +365,7 @@ declare const _default: {
     >
     'sort-imports': RuleModule<
       | 'missedSpacingBetweenImports'
+      | 'unexpectedImportsGroupOrder'
       | 'extraSpacingBetweenImports'
       | 'unexpectedImportsOrder',
       [
@@ -405,7 +409,7 @@ declare const _default: {
       RuleListener
     >
     'sort-objects': RuleModule<
-      'unexpectedObjectsOrder',
+      'unexpectedObjectsGroupOrder' | 'unexpectedObjectsOrder',
       [
         Partial<{
           customGroups: {

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

@@ -80,6 +80,8 @@ const sortAstroAttributes = createEslintRule.createEslintRule({
       },
     ],
     messages: {
+      unexpectedAstroAttributesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedAstroAttributesOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -162,10 +164,15 @@ const sortAstroAttributes = createEslintRule.createEslintRule({
                   isPositive.isPositive(compare.compare(left, right, options)))
               ) {
                 context.report({
-                  messageId: 'unexpectedAstroAttributesOrder',
+                  messageId:
+                    leftNum !== rightNum
+                      ? 'unexpectedAstroAttributesGroupOrder'
+                      : 'unexpectedAstroAttributesOrder',
                   data: {
                     left: left.name,
                     right: right.name,
+                    leftGroup: left.group,
+                    rightGroup: right.group,
                   },
                   node: right.node,
                   fix: fixer => {

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

@@ -79,6 +79,8 @@ const sortAstroAttributes = createEslintRule({
       },
     ],
     messages: {
+      unexpectedAstroAttributesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedAstroAttributesOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -159,10 +161,15 @@ const sortAstroAttributes = createEslintRule({
                   isPositive(compare(left, right, options)))
               ) {
                 context.report({
-                  messageId: 'unexpectedAstroAttributesOrder',
+                  messageId:
+                    leftNum !== rightNum
+                      ? 'unexpectedAstroAttributesGroupOrder'
+                      : 'unexpectedAstroAttributesOrder',
                   data: {
                     left: left.name,
                     right: right.name,
+                    leftGroup: left.group,
+                    rightGroup: right.group,
                   },
                   node: right.node,
                   fix: fixer => {

package/dist/rules/sort-classes.js

@@ -3,7 +3,7 @@ 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 getCommentsBefore = require('../utils/get-comments-before.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const getGroupNumber = require('../utils/get-group-number.js')
 const getSourceCode = require('../utils/get-source-code.js')
@@ -311,13 +311,15 @@ const sortClasses = createEslintRule.createEslintRule({
         let formattedNodes = node.body.reduce(
           (accumulator, member) => {
             var _a2, _b, _c, _d
-            let comment = getCommentBefore.getCommentBefore(member, sourceCode)
+            let comments = getCommentsBefore.getCommentsBefore(
+              member,
+              sourceCode,
+            )
             if (
               options.partitionByComment &&
-              comment &&
-              isPartitionComment.isPartitionComment(
+              isPartitionComment.hasPartitionComment(
                 options.partitionByComment,
-                comment.value,
+                comments,
               )
             ) {
               accumulator.push([])

package/dist/rules/sort-classes.mjs

@@ -10,8 +10,8 @@ import {
   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 { hasPartitionComment } from '../utils/is-partition-comment.mjs'
+import { getCommentsBefore } from '../utils/get-comments-before.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
 import { getGroupNumber } from '../utils/get-group-number.mjs'
 import { getSourceCode } from '../utils/get-source-code.mjs'
@@ -318,11 +318,10 @@ const sortClasses = createEslintRule({
         let formattedNodes = node.body.reduce(
           (accumulator, member) => {
             var _a2, _b, _c, _d
-            let comment = getCommentBefore(member, sourceCode)
+            let comments = getCommentsBefore(member, sourceCode)
             if (
               options.partitionByComment &&
-              comment &&
-              isPartitionComment(options.partitionByComment, comment.value)
+              hasPartitionComment(options.partitionByComment, comments)
             ) {
               accumulator.push([])
             }

package/dist/rules/sort-enums.js

@@ -1,8 +1,8 @@
 'use strict'
 const sortNodesByDependencies = require('../utils/sort-nodes-by-dependencies.js')
 const isPartitionComment = require('../utils/is-partition-comment.js')
+const getCommentsBefore = require('../utils/get-comments-before.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
-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')
@@ -131,20 +131,22 @@ const sortEnums = createEslintRule.createEslintRule({
             if ('right' in nodeValue) {
               checkNode(nodeValue.right)
             }
+            if ('expressions' in nodeValue) {
+              nodeValue.expressions.forEach(checkNode)
+            }
           }
           checkNode(expression)
           return dependencies
         }
         let formattedMembers = members.reduce(
           (accumulator, member) => {
-            let comment = getCommentBefore.getCommentBefore(member, sourceCode)
+            let comments = getCommentsBefore.getCommentsBefore(
+              member,
+              sourceCode,
+            )
             if (
               partitionComment &&
-              comment &&
-              isPartitionComment.isPartitionComment(
-                partitionComment,
-                comment.value,
-              )
+              isPartitionComment.hasPartitionComment(partitionComment, comments)
             ) {
               accumulator.push([])
             }

package/dist/rules/sort-enums.mjs

@@ -1,7 +1,7 @@
 import { sortNodesByDependencies } from '../utils/sort-nodes-by-dependencies.mjs'
-import { isPartitionComment } from '../utils/is-partition-comment.mjs'
+import { hasPartitionComment } from '../utils/is-partition-comment.mjs'
+import { getCommentsBefore } from '../utils/get-comments-before.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
-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'
@@ -130,17 +130,19 @@ const sortEnums = createEslintRule({
             if ('right' in nodeValue) {
               checkNode(nodeValue.right)
             }
+            if ('expressions' in nodeValue) {
+              nodeValue.expressions.forEach(checkNode)
+            }
           }
           checkNode(expression)
           return dependencies
         }
         let formattedMembers = members.reduce(
           (accumulator, member) => {
-            let comment = getCommentBefore(member, sourceCode)
+            let comments = getCommentsBefore(member, sourceCode)
             if (
               partitionComment &&
-              comment &&
-              isPartitionComment(partitionComment, comment.value)
+              hasPartitionComment(partitionComment, comments)
             ) {
               accumulator.push([])
             }

package/dist/rules/sort-imports.js

@@ -2,7 +2,7 @@
 const node_module = require('node:module')
 const minimatch = require('minimatch')
 const validateGroupsConfiguration = require('../utils/validate-groups-configuration.js')
-const getCommentBefore = require('../utils/get-comment-before.js')
+const getCommentsBefore = require('../utils/get-comments-before.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const getLinesBetween = require('../utils/get-lines-between.js')
 const getGroupNumber = require('../utils/get-group-number.js')
@@ -140,6 +140,8 @@ const sortImports = createEslintRule.createEslintRule({
       },
     ],
     messages: {
+      unexpectedImportsGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedImportsOrder: 'Expected "{{right}}" to come before "{{left}}".',
       missedSpacingBetweenImports:
         'Missed spacing between "{{left}}" and "{{right}}" imports.',
@@ -409,14 +411,11 @@ const sortImports = createEslintRule.createEslintRule({
       'Program:exit': () => {
         var _a
         let hasContentBetweenNodes = (left, right) =>
-          !!sourceCode.getTokensBetween(
-            left.node,
-            getCommentBefore.getCommentBefore(right.node, sourceCode) ||
-              right.node,
-            {
-              includeComments: true,
-            },
-          ).length
+          getCommentsBefore.getCommentsBefore(right.node, sourceCode).length >
+            0 ||
+          !!sourceCode.getTokensBetween(left.node, right.node, {
+            includeComments: false,
+          }).length
         let fix = (fixer, nodesToFix) => {
           let fixes = []
           let grouped = {}
@@ -550,10 +549,15 @@ const sortImports = createEslintRule.createEslintRule({
                   isPositive.isPositive(compare.compare(left, right, options))))
             ) {
               context.report({
-                messageId: 'unexpectedImportsOrder',
+                messageId:
+                  leftNum !== rightNum
+                    ? 'unexpectedImportsGroupOrder'
+                    : 'unexpectedImportsOrder',
                 data: {
                   left: left.name,
+                  leftGroup: left.group,
                   right: right.name,
+                  rightGroup: right.group,
                 },
                 node: right.node,
                 fix: fixer => fix(fixer, nodeList),

package/dist/rules/sort-imports.mjs

@@ -1,7 +1,7 @@
 import { builtinModules } from 'node:module'
 import { minimatch } from 'minimatch'
 import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.mjs'
-import { getCommentBefore } from '../utils/get-comment-before.mjs'
+import { getCommentsBefore } from '../utils/get-comments-before.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
 import { getLinesBetween } from '../utils/get-lines-between.mjs'
 import { getGroupNumber } from '../utils/get-group-number.mjs'
@@ -139,6 +139,8 @@ const sortImports = createEslintRule({
       },
     ],
     messages: {
+      unexpectedImportsGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedImportsOrder: 'Expected "{{right}}" to come before "{{left}}".',
       missedSpacingBetweenImports:
         'Missed spacing between "{{left}}" and "{{right}}" imports.',
@@ -404,13 +406,10 @@ const sortImports = createEslintRule({
       'Program:exit': () => {
         var _a
         let hasContentBetweenNodes = (left, right) =>
-          !!sourceCode.getTokensBetween(
-            left.node,
-            getCommentBefore(right.node, sourceCode) || right.node,
-            {
-              includeComments: true,
-            },
-          ).length
+          getCommentsBefore(right.node, sourceCode).length > 0 ||
+          !!sourceCode.getTokensBetween(left.node, right.node, {
+            includeComments: false,
+          }).length
         let fix = (fixer, nodesToFix) => {
           let fixes = []
           let grouped = {}
@@ -535,10 +534,15 @@ const sortImports = createEslintRule({
                   isPositive(compare(left, right, options))))
             ) {
               context.report({
-                messageId: 'unexpectedImportsOrder',
+                messageId:
+                  leftNum !== rightNum
+                    ? 'unexpectedImportsGroupOrder'
+                    : 'unexpectedImportsOrder',
                 data: {
                   left: left.name,
+                  leftGroup: left.group,
                   right: right.name,
+                  rightGroup: right.group,
                 },
                 node: right.node,
                 fix: fixer => fix(fixer, nodeList),

package/dist/rules/sort-interfaces.js

@@ -101,6 +101,8 @@ const sortInterfaces = createEslintRule.createEslintRule({
       },
     ],
     messages: {
+      unexpectedInterfacePropertiesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedInterfacePropertiesOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -271,11 +273,24 @@ const sortInterfaces = createEslintRule.createEslintRule({
           for (let nodes of formattedMembers) {
             pairwise.pairwise(nodes, (left, right, iteration) => {
               if (checkOrder(nodes, left, right, iteration)) {
+                let leftNum = getGroupNumber.getGroupNumber(
+                  options.groups,
+                  left,
+                )
+                let rightNum = getGroupNumber.getGroupNumber(
+                  options.groups,
+                  right,
+                )
                 context.report({
-                  messageId: 'unexpectedInterfacePropertiesOrder',
+                  messageId:
+                    leftNum !== rightNum
+                      ? 'unexpectedInterfacePropertiesGroupOrder'
+                      : 'unexpectedInterfacePropertiesOrder',
                   data: {
                     left: toSingleLine.toSingleLine(left.name),
+                    leftGroup: left.group,
                     right: toSingleLine.toSingleLine(right.name),
+                    rightGroup: right.group,
                   },
                   node: right.node,
                   fix: fixer => {

package/dist/rules/sort-interfaces.mjs

@@ -100,6 +100,8 @@ const sortInterfaces = createEslintRule({
       },
     ],
     messages: {
+      unexpectedInterfacePropertiesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedInterfacePropertiesOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -260,11 +262,18 @@ const sortInterfaces = createEslintRule({
           for (let nodes of formattedMembers) {
             pairwise(nodes, (left, right, iteration) => {
               if (checkOrder(nodes, left, right, iteration)) {
+                let leftNum = getGroupNumber(options.groups, left)
+                let rightNum = getGroupNumber(options.groups, right)
                 context.report({
-                  messageId: 'unexpectedInterfacePropertiesOrder',
+                  messageId:
+                    leftNum !== rightNum
+                      ? 'unexpectedInterfacePropertiesGroupOrder'
+                      : 'unexpectedInterfacePropertiesOrder',
                   data: {
                     left: toSingleLine(left.name),
+                    leftGroup: left.group,
                     right: toSingleLine(right.name),
+                    rightGroup: right.group,
                   },
                   node: right.node,
                   fix: fixer => {

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

@@ -63,6 +63,8 @@ const sortIntersectionTypes = createEslintRule.createEslintRule({
       },
     ],
     messages: {
+      unexpectedIntersectionTypesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedIntersectionTypesOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -180,10 +182,15 @@ const sortIntersectionTypes = createEslintRule.createEslintRule({
             isPositive.isPositive(compare.compare(left, right, options)))
         ) {
           context.report({
-            messageId: 'unexpectedIntersectionTypesOrder',
+            messageId:
+              leftNum !== rightNum
+                ? 'unexpectedIntersectionTypesGroupOrder'
+                : 'unexpectedIntersectionTypesOrder',
             data: {
               left: toSingleLine.toSingleLine(left.name),
+              leftGroup: left.group,
               right: toSingleLine.toSingleLine(right.name),
+              rightGroup: right.group,
             },
             node: right.node,
             fix: fixer => {

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

@@ -62,6 +62,8 @@ const sortIntersectionTypes = createEslintRule({
       },
     ],
     messages: {
+      unexpectedIntersectionTypesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedIntersectionTypesOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -178,10 +180,15 @@ const sortIntersectionTypes = createEslintRule({
           (leftNum === rightNum && isPositive(compare(left, right, options)))
         ) {
           context.report({
-            messageId: 'unexpectedIntersectionTypesOrder',
+            messageId:
+              leftNum !== rightNum
+                ? 'unexpectedIntersectionTypesGroupOrder'
+                : 'unexpectedIntersectionTypesOrder',
             data: {
               left: toSingleLine(left.name),
+              leftGroup: left.group,
               right: toSingleLine(right.name),
+              rightGroup: right.group,
             },
             node: right.node,
             fix: fixer => {

package/dist/rules/sort-jsx-props.js

@@ -88,6 +88,8 @@ const sortJsxProps = createEslintRule.createEslintRule({
       },
     ],
     messages: {
+      unexpectedJSXPropsGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedJSXPropsOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -171,10 +173,15 @@ const sortJsxProps = createEslintRule.createEslintRule({
                   isPositive.isPositive(compare.compare(left, right, options)))
               ) {
                 context.report({
-                  messageId: 'unexpectedJSXPropsOrder',
+                  messageId:
+                    leftNum !== rightNum
+                      ? 'unexpectedJSXPropsGroupOrder'
+                      : 'unexpectedJSXPropsOrder',
                   data: {
                     left: left.name,
+                    leftGroup: left.group,
                     right: right.name,
+                    rightGroup: right.group,
                   },
                   node: right.node,
                   fix: fixer => {

package/dist/rules/sort-jsx-props.mjs

@@ -87,6 +87,8 @@ const sortJsxProps = createEslintRule({
       },
     ],
     messages: {
+      unexpectedJSXPropsGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedJSXPropsOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -168,10 +170,15 @@ const sortJsxProps = createEslintRule({
                   isPositive(compare(left, right, options)))
               ) {
                 context.report({
-                  messageId: 'unexpectedJSXPropsOrder',
+                  messageId:
+                    leftNum !== rightNum
+                      ? 'unexpectedJSXPropsGroupOrder'
+                      : 'unexpectedJSXPropsOrder',
                   data: {
                     left: left.name,
+                    leftGroup: left.group,
                     right: right.name,
+                    rightGroup: right.group,
                   },
                   node: right.node,
                   fix: fixer => {

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

@@ -91,6 +91,8 @@ const sortObjectTypes = createEslintRule.createEslintRule({
       },
     ],
     messages: {
+      unexpectedObjectTypesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedObjectTypesOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -248,10 +250,15 @@ const sortObjectTypes = createEslintRule.createEslintRule({
             }
             if (compareValue) {
               context.report({
-                messageId: 'unexpectedObjectTypesOrder',
+                messageId:
+                  leftNum !== rightNum
+                    ? 'unexpectedObjectTypesGroupOrder'
+                    : 'unexpectedObjectTypesOrder',
                 data: {
                   left: toSingleLine.toSingleLine(left.name),
+                  leftGroup: left.group,
                   right: toSingleLine.toSingleLine(right.name),
+                  rightGroup: right.group,
                 },
                 node: right.node,
                 fix: fixer => {

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

@@ -90,6 +90,8 @@ const sortObjectTypes = createEslintRule({
       },
     ],
     messages: {
+      unexpectedObjectTypesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedObjectTypesOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -242,10 +244,15 @@ const sortObjectTypes = createEslintRule({
             }
             if (compareValue) {
               context.report({
-                messageId: 'unexpectedObjectTypesOrder',
+                messageId:
+                  leftNum !== rightNum
+                    ? 'unexpectedObjectTypesGroupOrder'
+                    : 'unexpectedObjectTypesOrder',
                 data: {
                   left: toSingleLine(left.name),
+                  leftGroup: left.group,
                   right: toSingleLine(right.name),
+                  rightGroup: right.group,
                 },
                 node: right.node,
                 fix: fixer => {