eslint-plugin-perfectionist 3.5.0 → 3.7.0

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

@@ -1,18 +1,16 @@
 'use strict'
 const path = require('node:path')
 const validateGroupsConfiguration = require('../utils/validate-groups-configuration.js')
+const sortNodesByGroups = require('../utils/sort-nodes-by-groups.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')
 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')
-const sortNodes = require('../utils/sort-nodes.js')
 const pairwise = require('../utils/pairwise.js')
 const complete = require('../utils/complete.js')
-const compare = require('../utils/compare.js')
 const sortAstroAttributes = createEslintRule.createEslintRule({
   name: 'sort-astro-attributes',
   meta: {
@@ -80,6 +78,8 @@ const sortAstroAttributes = createEslintRule.createEslintRule({
       },
     ],
     messages: {
+      unexpectedAstroAttributesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedAstroAttributesOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -150,55 +150,36 @@ const sortAstroAttributes = createEslintRule.createEslintRule({
             [[]],
           )
           for (let nodes of parts) {
+            let sortedNodes = sortNodesByGroups.sortNodesByGroups(
+              nodes,
+              options,
+            )
             pairwise.pairwise(nodes, (left, right) => {
-              let leftNum = getGroupNumber.getGroupNumber(options.groups, left)
-              let rightNum = getGroupNumber.getGroupNumber(
-                options.groups,
-                right,
-              )
-              if (
-                leftNum > rightNum ||
-                (leftNum === rightNum &&
-                  isPositive.isPositive(compare.compare(left, right, options)))
-              ) {
+              let indexOfLeft = sortedNodes.indexOf(left)
+              let indexOfRight = sortedNodes.indexOf(right)
+              if (indexOfLeft > indexOfRight) {
+                let leftNum = getGroupNumber.getGroupNumber(
+                  options.groups,
+                  left,
+                )
+                let rightNum = getGroupNumber.getGroupNumber(
+                  options.groups,
+                  right,
+                )
                 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 => {
-                    let grouped = {}
-                    for (let currentNode of nodes) {
-                      let groupNum = getGroupNumber.getGroupNumber(
-                        options.groups,
-                        currentNode,
-                      )
-                      if (!(groupNum in grouped)) {
-                        grouped[groupNum] = [currentNode]
-                      } else {
-                        grouped[groupNum] = sortNodes.sortNodes(
-                          [...grouped[groupNum], currentNode],
-                          options,
-                        )
-                      }
-                    }
-                    let sortedNodes = []
-                    for (let group of Object.keys(grouped).sort(
-                      (a, b) => Number(a) - Number(b),
-                    )) {
-                      sortedNodes.push(
-                        ...sortNodes.sortNodes(grouped[group], options),
-                      )
-                    }
-                    return makeFixes.makeFixes(
-                      fixer,
-                      nodes,
-                      sortedNodes,
-                      sourceCode,
-                    )
-                  },
+                  fix: fixer =>
+                    makeFixes.makeFixes(fixer, nodes, sortedNodes, sourceCode),
                 })
               }
             })

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

@@ -1,17 +1,15 @@
 import path from 'node:path'
 import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.mjs'
+import { sortNodesByGroups } from '../utils/sort-nodes-by-groups.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'
 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'
-import { sortNodes } from '../utils/sort-nodes.mjs'
 import { pairwise } from '../utils/pairwise.mjs'
 import { complete } from '../utils/complete.mjs'
-import { compare } from '../utils/compare.mjs'
 const sortAstroAttributes = createEslintRule({
   name: 'sort-astro-attributes',
   meta: {
@@ -79,6 +77,8 @@ const sortAstroAttributes = createEslintRule({
       },
     ],
     messages: {
+      unexpectedAstroAttributesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedAstroAttributesOrder:
         'Expected "{{right}}" to come before "{{left}}".',
     },
@@ -150,42 +150,27 @@ const sortAstroAttributes = createEslintRule({
             [[]],
           )
           for (let nodes of parts) {
+            let sortedNodes = sortNodesByGroups(nodes, options)
             pairwise(nodes, (left, right) => {
-              let leftNum = getGroupNumber(options.groups, left)
-              let rightNum = getGroupNumber(options.groups, right)
-              if (
-                leftNum > rightNum ||
-                (leftNum === rightNum &&
-                  isPositive(compare(left, right, options)))
-              ) {
+              let indexOfLeft = sortedNodes.indexOf(left)
+              let indexOfRight = sortedNodes.indexOf(right)
+              if (indexOfLeft > indexOfRight) {
+                let leftNum = getGroupNumber(options.groups, left)
+                let rightNum = getGroupNumber(options.groups, right)
                 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 => {
-                    let grouped = {}
-                    for (let currentNode of nodes) {
-                      let groupNum = getGroupNumber(options.groups, currentNode)
-                      if (!(groupNum in grouped)) {
-                        grouped[groupNum] = [currentNode]
-                      } else {
-                        grouped[groupNum] = sortNodes(
-                          [...grouped[groupNum], currentNode],
-                          options,
-                        )
-                      }
-                    }
-                    let sortedNodes = []
-                    for (let group of Object.keys(grouped).sort(
-                      (a, b) => Number(a) - Number(b),
-                    )) {
-                      sortedNodes.push(...sortNodes(grouped[group], options))
-                    }
-                    return makeFixes(fixer, nodes, sortedNodes, sourceCode)
-                  },
+                  fix: fixer =>
+                    makeFixes(fixer, nodes, sortedNodes, sourceCode),
                 })
               }
             })

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')
@@ -45,7 +45,7 @@ const sortClasses = createEslintRule.createEslintRule({
           },
           partitionByComment: {
             description:
-              'Allows to use comments to separate the nodes into logical groups.',
+              'Allows to use comments to separate the class members into logical groups.',
             anyOf: [
               {
                 type: 'array',
@@ -145,6 +145,8 @@ const sortClasses = createEslintRule.createEslintRule({
       unexpectedClassesGroupOrder:
         'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedClassesOrder: 'Expected "{{right}}" to come before "{{left}}".',
+      unexpectedClassesDependencyOrder:
+        'Expected dependency "{{right}}" to come before "{{nodeDependentOnRight}}".',
     },
   },
   defaultOptions: [
@@ -311,13 +313,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([])
@@ -530,10 +534,11 @@ const sortClasses = createEslintRule.createEslintRule({
           },
           [[]],
         )
-        for (let nodes of formattedNodes) {
+        let sortedNodes = []
+        for (let nodes2 of formattedNodes) {
           let nodesByNonIgnoredGroupNumber = {}
           let ignoredNodeIndices = []
-          for (let [index, sortingNode] of nodes.entries()) {
+          for (let [index, sortingNode] of nodes2.entries()) {
             let groupNum = getGroupNumber.getGroupNumber(
               options.groups,
               sortingNode,
@@ -546,7 +551,6 @@ const sortClasses = createEslintRule.createEslintRule({
               nodesByNonIgnoredGroupNumber[groupNum] ?? []
             nodesByNonIgnoredGroupNumber[groupNum].push(sortingNode)
           }
-          let sortedNodes = []
           for (let groupNumber of Object.keys(
             nodesByNonIgnoredGroupNumber,
           ).sort((a, b) => Number(a) - Number(b))) {
@@ -568,39 +572,58 @@ const sortClasses = createEslintRule.createEslintRule({
             }
           }
           for (let ignoredIndex of ignoredNodeIndices) {
-            sortedNodes.splice(ignoredIndex, 0, nodes[ignoredIndex])
+            sortedNodes.splice(ignoredIndex, 0, nodes2[ignoredIndex])
           }
-          sortedNodes =
-            sortNodesByDependencies.sortNodesByDependencies(sortedNodes)
-          pairwise.pairwise(nodes, (left, right) => {
-            let leftNum = getGroupNumber.getGroupNumber(options.groups, left)
-            let rightNum = getGroupNumber.getGroupNumber(options.groups, right)
-            let isLeftOrRightIgnored =
-              leftNum === options.groups.length ||
-              rightNum === options.groups.length
-            let indexOfLeft = sortedNodes.indexOf(left)
-            let indexOfRight = sortedNodes.indexOf(right)
-            if (!isLeftOrRightIgnored && indexOfLeft > indexOfRight) {
-              context.report({
-                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 =>
-                  makeFixes.makeFixes(fixer, nodes, sortedNodes, sourceCode, {
-                    partitionComment: options.partitionByComment,
-                  }),
-              })
-            }
-          })
         }
+        sortedNodes =
+          sortNodesByDependencies.sortNodesByDependencies(sortedNodes)
+        let nodes = formattedNodes.flat()
+        pairwise.pairwise(nodes, (left, right) => {
+          let leftNum = getGroupNumber.getGroupNumber(options.groups, left)
+          let rightNum = getGroupNumber.getGroupNumber(options.groups, right)
+          let isLeftOrRightIgnored =
+            leftNum === options.groups.length ||
+            rightNum === options.groups.length
+          let indexOfLeft = sortedNodes.indexOf(left)
+          let indexOfRight = sortedNodes.indexOf(right)
+          let firstUnorderedNodeDependentOnRight =
+            sortNodesByDependencies.getFirstUnorderedNodeDependentOn(
+              right,
+              nodes,
+            )
+          if (
+            firstUnorderedNodeDependentOnRight ||
+            (!isLeftOrRightIgnored && indexOfLeft > indexOfRight)
+          ) {
+            let messageId
+            if (firstUnorderedNodeDependentOnRight) {
+              messageId = 'unexpectedClassesDependencyOrder'
+            } else {
+              messageId =
+                leftNum !== rightNum
+                  ? 'unexpectedClassesGroupOrder'
+                  : 'unexpectedClassesOrder'
+            }
+            context.report({
+              messageId,
+              data: {
+                left: toSingleLine.toSingleLine(left.name),
+                leftGroup: left.group,
+                right: toSingleLine.toSingleLine(right.name),
+                rightGroup: right.group,
+                nodeDependentOnRight:
+                  firstUnorderedNodeDependentOnRight == null
+                    ? void 0
+                    : firstUnorderedNodeDependentOnRight.name,
+              },
+              node: right.node,
+              fix: fixer =>
+                makeFixes.makeFixes(fixer, nodes, sortedNodes, sourceCode, {
+                  partitionComment: options.partitionByComment,
+                }),
+            })
+          }
+        })
       }
     },
   }),

package/dist/rules/sort-classes.mjs

@@ -9,9 +9,12 @@ import {
   customGroupSortJsonSchema,
   singleCustomGroupJsonSchema,
 } from './sort-classes.types.mjs'
-import { sortNodesByDependencies } from '../utils/sort-nodes-by-dependencies.mjs'
-import { isPartitionComment } from '../utils/is-partition-comment.mjs'
-import { getCommentBefore } from '../utils/get-comment-before.mjs'
+import {
+  sortNodesByDependencies,
+  getFirstUnorderedNodeDependentOn,
+} from '../utils/sort-nodes-by-dependencies.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'
@@ -53,7 +56,7 @@ const sortClasses = createEslintRule({
           },
           partitionByComment: {
             description:
-              'Allows to use comments to separate the nodes into logical groups.',
+              'Allows to use comments to separate the class members into logical groups.',
             anyOf: [
               {
                 type: 'array',
@@ -153,6 +156,8 @@ const sortClasses = createEslintRule({
       unexpectedClassesGroupOrder:
         'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
       unexpectedClassesOrder: 'Expected "{{right}}" to come before "{{left}}".',
+      unexpectedClassesDependencyOrder:
+        'Expected dependency "{{right}}" to come before "{{nodeDependentOnRight}}".',
     },
   },
   defaultOptions: [
@@ -318,11 +323,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([])
             }
@@ -535,10 +539,11 @@ const sortClasses = createEslintRule({
           },
           [[]],
         )
-        for (let nodes of formattedNodes) {
+        let sortedNodes = []
+        for (let nodes2 of formattedNodes) {
           let nodesByNonIgnoredGroupNumber = {}
           let ignoredNodeIndices = []
-          for (let [index, sortingNode] of nodes.entries()) {
+          for (let [index, sortingNode] of nodes2.entries()) {
             let groupNum = getGroupNumber(options.groups, sortingNode)
             if (groupNum === options.groups.length) {
               ignoredNodeIndices.push(index)
@@ -548,7 +553,6 @@ const sortClasses = createEslintRule({
               nodesByNonIgnoredGroupNumber[groupNum] ?? []
             nodesByNonIgnoredGroupNumber[groupNum].push(sortingNode)
           }
-          let sortedNodes = []
           for (let groupNumber of Object.keys(
             nodesByNonIgnoredGroupNumber,
           ).sort((a, b) => Number(a) - Number(b))) {
@@ -567,38 +571,54 @@ const sortClasses = createEslintRule({
             }
           }
           for (let ignoredIndex of ignoredNodeIndices) {
-            sortedNodes.splice(ignoredIndex, 0, nodes[ignoredIndex])
+            sortedNodes.splice(ignoredIndex, 0, nodes2[ignoredIndex])
           }
-          sortedNodes = sortNodesByDependencies(sortedNodes)
-          pairwise(nodes, (left, right) => {
-            let leftNum = getGroupNumber(options.groups, left)
-            let rightNum = getGroupNumber(options.groups, right)
-            let isLeftOrRightIgnored =
-              leftNum === options.groups.length ||
-              rightNum === options.groups.length
-            let indexOfLeft = sortedNodes.indexOf(left)
-            let indexOfRight = sortedNodes.indexOf(right)
-            if (!isLeftOrRightIgnored && indexOfLeft > indexOfRight) {
-              context.report({
-                messageId:
-                  leftNum !== rightNum
-                    ? 'unexpectedClassesGroupOrder'
-                    : 'unexpectedClassesOrder',
-                data: {
-                  left: toSingleLine(left.name),
-                  leftGroup: left.group,
-                  right: toSingleLine(right.name),
-                  rightGroup: right.group,
-                },
-                node: right.node,
-                fix: fixer =>
-                  makeFixes(fixer, nodes, sortedNodes, sourceCode, {
-                    partitionComment: options.partitionByComment,
-                  }),
-              })
-            }
-          })
         }
+        sortedNodes = sortNodesByDependencies(sortedNodes)
+        let nodes = formattedNodes.flat()
+        pairwise(nodes, (left, right) => {
+          let leftNum = getGroupNumber(options.groups, left)
+          let rightNum = getGroupNumber(options.groups, right)
+          let isLeftOrRightIgnored =
+            leftNum === options.groups.length ||
+            rightNum === options.groups.length
+          let indexOfLeft = sortedNodes.indexOf(left)
+          let indexOfRight = sortedNodes.indexOf(right)
+          let firstUnorderedNodeDependentOnRight =
+            getFirstUnorderedNodeDependentOn(right, nodes)
+          if (
+            firstUnorderedNodeDependentOnRight ||
+            (!isLeftOrRightIgnored && indexOfLeft > indexOfRight)
+          ) {
+            let messageId
+            if (firstUnorderedNodeDependentOnRight) {
+              messageId = 'unexpectedClassesDependencyOrder'
+            } else {
+              messageId =
+                leftNum !== rightNum
+                  ? 'unexpectedClassesGroupOrder'
+                  : 'unexpectedClassesOrder'
+            }
+            context.report({
+              messageId,
+              data: {
+                left: toSingleLine(left.name),
+                leftGroup: left.group,
+                right: toSingleLine(right.name),
+                rightGroup: right.group,
+                nodeDependentOnRight:
+                  firstUnorderedNodeDependentOnRight == null
+                    ? void 0
+                    : firstUnorderedNodeDependentOnRight.name,
+              },
+              node: right.node,
+              fix: fixer =>
+                makeFixes(fixer, nodes, sortedNodes, sourceCode, {
+                  partitionComment: options.partitionByComment,
+                }),
+            })
+          }
+        })
       }
     },
   }),