eslint-plugin-perfectionist 3.4.0 → 3.6.0

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 => {

package/dist/rules/sort-objects.js

@@ -3,7 +3,7 @@ const minimatch = require('minimatch')
 const validateGroupsConfiguration = require('../utils/validate-groups-configuration.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 getLinesBetween = require('../utils/get-lines-between.js')
 const getGroupNumber = require('../utils/get-group-number.js')
@@ -123,6 +123,8 @@ const sortObjects = createEslintRule.createEslintRule({
       },
     ],
     messages: {
+      unexpectedObjectsGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedObjectsOrder: 'Expected "{{right}}" to come before "{{left}}".',
     },
   },
@@ -220,6 +222,69 @@ const sortObjects = createEslintRule.createEslintRule({
           return
         }
         let sourceCode = getSourceCode.getSourceCode(context)
+        let extractDependencies = init => {
+          let dependencies = []
+          let checkNode = nodeValue => {
+            if (
+              nodeValue.type === 'ArrowFunctionExpression' ||
+              nodeValue.type === 'FunctionExpression'
+            ) {
+              return
+            }
+            if (nodeValue.type === 'Identifier') {
+              dependencies.push(nodeValue.name)
+            }
+            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 ('left' in nodeValue) {
+              traverseNode(nodeValue.left)
+            }
+            if ('right' in nodeValue) {
+              traverseNode(nodeValue.right)
+            }
+            if ('elements' in nodeValue) {
+              nodeValue.elements
+                .filter(currentNode => currentNode !== null)
+                .forEach(traverseNode)
+            }
+            if ('argument' in nodeValue && nodeValue.argument) {
+              traverseNode(nodeValue.argument)
+            }
+            if ('arguments' in nodeValue) {
+              nodeValue.arguments.forEach(traverseNode)
+            }
+            if ('properties' in nodeValue) {
+              nodeValue.properties.forEach(traverseNode)
+            }
+            if ('expressions' in nodeValue) {
+              nodeValue.expressions.forEach(traverseNode)
+            }
+          }
+          let traverseNode = nodeValue => {
+            checkNode(nodeValue)
+          }
+          traverseNode(init)
+          return dependencies
+        }
         let formatProperties = props =>
           props.reduce(
             (accumulator, prop) => {
@@ -231,15 +296,17 @@ const sortObjects = createEslintRule.createEslintRule({
                 accumulator.push([])
                 return accumulator
               }
-              let comment = getCommentBefore.getCommentBefore(prop, sourceCode)
+              let comments = getCommentsBefore.getCommentsBefore(
+                prop,
+                sourceCode,
+              )
               let lastProp =
                 (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1)
               if (
                 options.partitionByComment &&
-                comment &&
-                isPartitionComment.isPartitionComment(
+                isPartitionComment.hasPartitionComment(
                   options.partitionByComment,
-                  comment.value,
+                  comments,
                 )
               ) {
                 accumulator.push([])
@@ -274,50 +341,7 @@ const sortObjects = createEslintRule.createEslintRule({
                 accumulator.push([])
               }
               if (prop.value.type === 'AssignmentPattern') {
-                let addDependencies = value2 => {
-                  if (value2.right.type === 'Identifier') {
-                    dependencies.push(value2.right.name)
-                  }
-                  let handleComplexExpression = expression => {
-                    let nodes = []
-                    switch (expression.type) {
-                      case 'ArrowFunctionExpression':
-                        nodes.push(expression.body)
-                        break
-                      case 'ConditionalExpression':
-                        nodes.push(expression.consequent, expression.alternate)
-                        break
-                      case 'LogicalExpression':
-                      case 'BinaryExpression':
-                        nodes.push(expression.left, expression.right)
-                        break
-                      case 'CallExpression':
-                        nodes.push(...expression.arguments)
-                        break
-                    }
-                    nodes.forEach(nestedNode => {
-                      if (nestedNode.type === 'Identifier') {
-                        dependencies.push(nestedNode.name)
-                      }
-                      if (
-                        nestedNode.type === 'BinaryExpression' ||
-                        nestedNode.type === 'ConditionalExpression'
-                      ) {
-                        handleComplexExpression(nestedNode)
-                      }
-                    })
-                  }
-                  switch (value2.right.type) {
-                    case 'ArrowFunctionExpression':
-                    case 'ConditionalExpression':
-                    case 'LogicalExpression':
-                    case 'BinaryExpression':
-                    case 'CallExpression':
-                      handleComplexExpression(value2.right)
-                      break
-                  }
-                }
-                addDependencies(prop.value)
+                dependencies = extractDependencies(prop.value)
               }
               setCustomGroups(options.customGroups, name)
               let value = {
@@ -360,11 +384,21 @@ const sortObjects = createEslintRule.createEslintRule({
                 makeFixes.makeFixes(fixer, nodes, sortedNodes, sourceCode, {
                   partitionComment: options.partitionByComment,
                 })
+              let leftNum = getGroupNumber.getGroupNumber(options.groups, left)
+              let rightNum = getGroupNumber.getGroupNumber(
+                options.groups,
+                right,
+              )
               context.report({
-                messageId: 'unexpectedObjectsOrder',
+                messageId:
+                  leftNum !== rightNum
+                    ? 'unexpectedObjectsGroupOrder'
+                    : 'unexpectedObjectsOrder',
                 data: {
                   left: toSingleLine.toSingleLine(left.name),
+                  leftGroup: left.group,
                   right: toSingleLine.toSingleLine(right.name),
+                  rightGroup: right.group,
                 },
                 node: right.node,
                 fix,

package/dist/rules/sort-objects.mjs

@@ -1,8 +1,8 @@
 import { minimatch } from 'minimatch'
 import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.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 { getLinesBetween } from '../utils/get-lines-between.mjs'
 import { getGroupNumber } from '../utils/get-group-number.mjs'
@@ -122,6 +122,8 @@ const sortObjects = createEslintRule({
       },
     ],
     messages: {
+      unexpectedObjectsGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedObjectsOrder: 'Expected "{{right}}" to come before "{{left}}".',
     },
   },
@@ -216,6 +218,69 @@ const sortObjects = createEslintRule({
           return
         }
         let sourceCode = getSourceCode(context)
+        let extractDependencies = init => {
+          let dependencies = []
+          let checkNode = nodeValue => {
+            if (
+              nodeValue.type === 'ArrowFunctionExpression' ||
+              nodeValue.type === 'FunctionExpression'
+            ) {
+              return
+            }
+            if (nodeValue.type === 'Identifier') {
+              dependencies.push(nodeValue.name)
+            }
+            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 ('left' in nodeValue) {
+              traverseNode(nodeValue.left)
+            }
+            if ('right' in nodeValue) {
+              traverseNode(nodeValue.right)
+            }
+            if ('elements' in nodeValue) {
+              nodeValue.elements
+                .filter(currentNode => currentNode !== null)
+                .forEach(traverseNode)
+            }
+            if ('argument' in nodeValue && nodeValue.argument) {
+              traverseNode(nodeValue.argument)
+            }
+            if ('arguments' in nodeValue) {
+              nodeValue.arguments.forEach(traverseNode)
+            }
+            if ('properties' in nodeValue) {
+              nodeValue.properties.forEach(traverseNode)
+            }
+            if ('expressions' in nodeValue) {
+              nodeValue.expressions.forEach(traverseNode)
+            }
+          }
+          let traverseNode = nodeValue => {
+            checkNode(nodeValue)
+          }
+          traverseNode(init)
+          return dependencies
+        }
         let formatProperties = props =>
           props.reduce(
             (accumulator, prop) => {
@@ -227,13 +292,12 @@ const sortObjects = createEslintRule({
                 accumulator.push([])
                 return accumulator
               }
-              let comment = getCommentBefore(prop, sourceCode)
+              let comments = getCommentsBefore(prop, sourceCode)
               let lastProp =
                 (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1)
               if (
                 options.partitionByComment &&
-                comment &&
-                isPartitionComment(options.partitionByComment, comment.value)
+                hasPartitionComment(options.partitionByComment, comments)
               ) {
                 accumulator.push([])
               }
@@ -261,50 +325,7 @@ const sortObjects = createEslintRule({
                 accumulator.push([])
               }
               if (prop.value.type === 'AssignmentPattern') {
-                let addDependencies = value2 => {
-                  if (value2.right.type === 'Identifier') {
-                    dependencies.push(value2.right.name)
-                  }
-                  let handleComplexExpression = expression => {
-                    let nodes = []
-                    switch (expression.type) {
-                      case 'ArrowFunctionExpression':
-                        nodes.push(expression.body)
-                        break
-                      case 'ConditionalExpression':
-                        nodes.push(expression.consequent, expression.alternate)
-                        break
-                      case 'LogicalExpression':
-                      case 'BinaryExpression':
-                        nodes.push(expression.left, expression.right)
-                        break
-                      case 'CallExpression':
-                        nodes.push(...expression.arguments)
-                        break
-                    }
-                    nodes.forEach(nestedNode => {
-                      if (nestedNode.type === 'Identifier') {
-                        dependencies.push(nestedNode.name)
-                      }
-                      if (
-                        nestedNode.type === 'BinaryExpression' ||
-                        nestedNode.type === 'ConditionalExpression'
-                      ) {
-                        handleComplexExpression(nestedNode)
-                      }
-                    })
-                  }
-                  switch (value2.right.type) {
-                    case 'ArrowFunctionExpression':
-                    case 'ConditionalExpression':
-                    case 'LogicalExpression':
-                    case 'BinaryExpression':
-                    case 'CallExpression':
-                      handleComplexExpression(value2.right)
-                      break
-                  }
-                }
-                addDependencies(prop.value)
+                dependencies = extractDependencies(prop.value)
               }
               setCustomGroups(options.customGroups, name)
               let value = {
@@ -343,11 +364,18 @@ const sortObjects = createEslintRule({
                 makeFixes(fixer, nodes, sortedNodes, sourceCode, {
                   partitionComment: options.partitionByComment,
                 })
+              let leftNum = getGroupNumber(options.groups, left)
+              let rightNum = getGroupNumber(options.groups, right)
               context.report({
-                messageId: 'unexpectedObjectsOrder',
+                messageId:
+                  leftNum !== rightNum
+                    ? 'unexpectedObjectsGroupOrder'
+                    : 'unexpectedObjectsOrder',
                 data: {
                   left: toSingleLine(left.name),
+                  leftGroup: left.group,
                   right: toSingleLine(right.name),
+                  rightGroup: right.group,
                 },
                 node: right.node,
                 fix,

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

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

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

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

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

@@ -63,6 +63,8 @@ const sortUnionTypes = createEslintRule.createEslintRule({
       },
     ],
     messages: {
+      unexpectedUnionTypesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedUnionTypesOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -180,10 +182,15 @@ const sortUnionTypes = createEslintRule.createEslintRule({
             isPositive.isPositive(compare.compare(left, right, options)))
         ) {
           context.report({
-            messageId: 'unexpectedUnionTypesOrder',
+            messageId:
+              leftNum !== rightNum
+                ? 'unexpectedUnionTypesGroupOrder'
+                : 'unexpectedUnionTypesOrder',
             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-union-types.mjs

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

package/dist/rules/sort-variable-declarations.js

@@ -64,20 +64,37 @@ const sortVariableDeclarations = createEslintRule.createEslintRule({
         })
         let sourceCode = getSourceCode.getSourceCode(context)
         let extractDependencies = init => {
-          if (!init) {
-            return []
-          }
           let dependencies = []
           let checkNode = nodeValue => {
+            if (
+              nodeValue.type === 'ArrowFunctionExpression' ||
+              nodeValue.type === 'FunctionExpression'
+            ) {
+              return
+            }
             if (nodeValue.type === 'Identifier') {
               dependencies.push(nodeValue.name)
             }
+            if (nodeValue.type === 'Property') {
+              traverseNode(nodeValue.key)
+              traverseNode(nodeValue.value)
+            }
+            if (nodeValue.type === 'ConditionalExpression') {
+              traverseNode(nodeValue.test)
+              traverseNode(nodeValue.consequent)
+              traverseNode(nodeValue.alternate)
+            }
             if (
-              'body' in nodeValue &&
-              nodeValue.body &&
-              !Array.isArray(nodeValue.body)
+              'expression' in nodeValue &&
+              typeof nodeValue.expression !== 'boolean'
             ) {
-              traverseNode(nodeValue.body)
+              traverseNode(nodeValue.expression)
+            }
+            if ('object' in nodeValue) {
+              traverseNode(nodeValue.object)
+            }
+            if ('callee' in nodeValue) {
+              traverseNode(nodeValue.callee)
             }
             if ('left' in nodeValue) {
               traverseNode(nodeValue.left)
@@ -89,9 +106,19 @@ const sortVariableDeclarations = createEslintRule.createEslintRule({
               nodeValue.elements
                 .filter(currentNode => currentNode !== null)
                 .forEach(traverseNode)
-            } else if ('arguments' in nodeValue) {
+            }
+            if ('argument' in nodeValue && nodeValue.argument) {
+              traverseNode(nodeValue.argument)
+            }
+            if ('arguments' in nodeValue) {
               nodeValue.arguments.forEach(traverseNode)
             }
+            if ('properties' in nodeValue) {
+              nodeValue.properties.forEach(traverseNode)
+            }
+            if ('expressions' in nodeValue) {
+              nodeValue.expressions.forEach(traverseNode)
+            }
           }
           let traverseNode = nodeValue => {
             checkNode(nodeValue)
@@ -109,7 +136,10 @@ const sortVariableDeclarations = createEslintRule.createEslintRule({
           } else {
             ;({ name } = declaration.id)
           }
-          let dependencies = extractDependencies(declaration.init)
+          let dependencies = []
+          if (declaration.init) {
+            dependencies = extractDependencies(declaration.init)
+          }
           return {
             size: rangeToDiff.rangeToDiff(declaration.range),
             node: declaration,