eslint-plugin-perfectionist 3.5.0 → 3.6.0

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,9 +64,6 @@ const sortVariableDeclarations = createEslintRule.createEslintRule({
         })
         let sourceCode = getSourceCode.getSourceCode(context)
         let extractDependencies = init => {
-          if (!init) {
-            return []
-          }
           let dependencies = []
           let checkNode = nodeValue => {
             if (
@@ -139,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,

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

@@ -63,9 +63,6 @@ const sortVariableDeclarations = createEslintRule({
         })
         let sourceCode = getSourceCode(context)
         let extractDependencies = init => {
-          if (!init) {
-            return []
-          }
           let dependencies = []
           let checkNode = nodeValue => {
             if (
@@ -138,7 +135,10 @@ const sortVariableDeclarations = createEslintRule({
           } else {
             ;({ name } = declaration.id)
           }
-          let dependencies = extractDependencies(declaration.init)
+          let dependencies = []
+          if (declaration.init) {
+            dependencies = extractDependencies(declaration.init)
+          }
           return {
             size: rangeToDiff(declaration.range),
             node: declaration,

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

@@ -79,6 +79,8 @@ const sortVueAttributes = createEslintRule.createEslintRule({
       },
     ],
     messages: {
+      unexpectedVueAttributesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedVueAttributesOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -167,10 +169,15 @@ const sortVueAttributes = createEslintRule.createEslintRule({
                   isPositive.isPositive(compare.compare(left, right, options)))
               ) {
                 context.report({
-                  messageId: 'unexpectedVueAttributesOrder',
+                  messageId:
+                    leftNum !== rightNum
+                      ? 'unexpectedVueAttributesGroupOrder'
+                      : 'unexpectedVueAttributesOrder',
                   data: {
                     left: left.name,
+                    leftGroup: left.group,
                     right: right.name,
+                    rightGroup: right.group,
                   },
                   // @ts-ignore
                   node: right.node,

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

@@ -78,6 +78,8 @@ const sortVueAttributes = createEslintRule({
       },
     ],
     messages: {
+      unexpectedVueAttributesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedVueAttributesOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -164,10 +166,15 @@ const sortVueAttributes = createEslintRule({
                   isPositive(compare(left, right, options)))
               ) {
                 context.report({
-                  messageId: 'unexpectedVueAttributesOrder',
+                  messageId:
+                    leftNum !== rightNum
+                      ? 'unexpectedVueAttributesGroupOrder'
+                      : 'unexpectedVueAttributesOrder',
                   data: {
                     left: left.name,
+                    leftGroup: left.group,
                     right: right.name,
+                    rightGroup: right.group,
                   },
                   // @ts-ignore
                   node: right.node,

package/dist/utils/get-comments-before.js

@@ -0,0 +1,12 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+let getCommentsBefore = (node, source) =>
+  source.getCommentsBefore(node).filter(comment => {
+    let tokenBeforeComment = source.getTokenBefore(comment)
+    return (
+      (tokenBeforeComment == null
+        ? void 0
+        : tokenBeforeComment.loc.end.line) !== comment.loc.end.line
+    )
+  })
+exports.getCommentsBefore = getCommentsBefore

package/dist/utils/get-comments-before.mjs

@@ -0,0 +1,10 @@
+let getCommentsBefore = (node, source) =>
+  source.getCommentsBefore(node).filter(comment => {
+    let tokenBeforeComment = source.getTokenBefore(comment)
+    return (
+      (tokenBeforeComment == null
+        ? void 0
+        : tokenBeforeComment.loc.end.line) !== comment.loc.end.line
+    )
+  })
+export { getCommentsBefore }

package/dist/utils/get-node-range.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 const utils = require('@typescript-eslint/utils')
 const isPartitionComment = require('./is-partition-comment.js')
-const getCommentBefore = require('./get-comment-before.js')
+const getCommentsBefore = require('./get-comments-before.js')
 let getNodeRange = (node, sourceCode, additionalOptions) => {
   var _a
   let start = node.range.at(0)
@@ -20,7 +20,6 @@ let getNodeRange = (node, sourceCode, additionalOptions) => {
     start = bodyOpeningParen.range.at(0)
     end = bodyClosingParen.range.at(1)
   }
-  let comment = getCommentBefore.getCommentBefore(node, sourceCode)
   if (raw.endsWith(';') || raw.endsWith(',')) {
     let tokensAfter = sourceCode.getTokensAfter(node, {
       includeComments: true,
@@ -33,16 +32,31 @@ let getNodeRange = (node, sourceCode, additionalOptions) => {
       end -= 1
     }
   }
-  if (
-    comment &&
-    !isPartitionComment.isPartitionComment(
-      (additionalOptions == null
-        ? void 0
-        : additionalOptions.partitionComment) ?? false,
-      comment.value,
-    )
-  ) {
-    start = comment.range.at(0)
+  let comments = getCommentsBefore.getCommentsBefore(node, sourceCode)
+  let relevantTopComment
+  for (let i = comments.length - 1; i >= 0; i--) {
+    let comment = comments[i]
+    if (
+      isPartitionComment.isPartitionComment(
+        (additionalOptions == null
+          ? void 0
+          : additionalOptions.partitionComment) ?? false,
+        comment.value,
+      )
+    ) {
+      break
+    }
+    let previousCommentOrNodeStartLine =
+      i === comments.length - 1
+        ? node.loc.start.line
+        : comments[i + 1].loc.start.line
+    if (comment.loc.end.line !== previousCommentOrNodeStartLine - 1) {
+      break
+    }
+    relevantTopComment = comment
+  }
+  if (relevantTopComment) {
+    start = relevantTopComment.range.at(0)
   }
   return [start, end]
 }