eslint-plugin-perfectionist 3.6.0 → 3.7.0

package/dist/index.d.ts

@@ -108,10 +108,13 @@ declare const _default: {
   }
   rules: {
     'sort-variable-declarations': RuleModule<
-      'unexpectedVariableDeclarationsOrder',
+      | 'unexpectedVariableDeclarationsDependencyOrder'
+      | 'unexpectedVariableDeclarationsOrder',
       [
         Partial<{
           type: 'alphabetical' | 'line-length' | 'natural'
+          partitionByComment: string[] | boolean | string
+          partitionByNewLine: boolean
           order: 'desc' | 'asc'
           ignoreCase: boolean
         }>,
@@ -125,6 +128,7 @@ declare const _default: {
       [
         Partial<{
           type: 'alphabetical' | 'line-length' | 'natural'
+          partitionByComment: string[] | boolean | string
           groups: (
             | (
                 | 'object'
@@ -157,6 +161,7 @@ declare const _default: {
                 | 'union'
               )
           )[]
+          partitionByNewLine: boolean
           order: 'desc' | 'asc'
           ignoreCase: boolean
         }>,
@@ -225,6 +230,8 @@ declare const _default: {
         Partial<{
           groupKind: 'values-first' | 'types-first' | 'mixed'
           type: 'alphabetical' | 'line-length' | 'natural'
+          partitionByComment: string[] | boolean | string
+          partitionByNewLine: boolean
           order: 'desc' | 'asc'
           ignoreAlias: boolean
           ignoreCase: boolean
@@ -239,6 +246,8 @@ declare const _default: {
         Partial<{
           groupKind: 'values-first' | 'types-first' | 'mixed'
           type: 'alphabetical' | 'line-length' | 'natural'
+          partitionByComment: string[] | boolean | string
+          partitionByNewLine: boolean
           order: 'desc' | 'asc'
           ignoreCase: boolean
         }>,
@@ -255,6 +264,7 @@ declare const _default: {
             [x: string]: string | string[]
           }
           type: 'alphabetical' | 'line-length' | 'natural'
+          partitionByComment: string[] | boolean | string
           groups: (string | string[])[]
           partitionByNewLine: boolean
           order: 'desc' | 'asc'
@@ -269,6 +279,7 @@ declare const _default: {
       [
         Partial<{
           type: 'alphabetical' | 'line-length' | 'natural'
+          partitionByComment: string[] | boolean | string
           groups: (
             | (
                 | 'object'
@@ -301,6 +312,7 @@ declare const _default: {
                 | 'union'
               )
           )[]
+          partitionByNewLine: boolean
           order: 'desc' | 'asc'
           ignoreCase: boolean
         }>,
@@ -330,6 +342,7 @@ declare const _default: {
             [key: string]: string[] | string
           }
           type: 'alphabetical' | 'line-length' | 'natural'
+          partitionByComment: string[] | boolean | string
           groups: (string | string[])[]
           partitionByNewLine: boolean
           ignorePattern: string[]
@@ -358,7 +371,9 @@ declare const _default: {
       RuleListener
     >
     'sort-classes': RuleModule<
-      'unexpectedClassesGroupOrder' | 'unexpectedClassesOrder',
+      | 'unexpectedClassesDependencyOrder'
+      | 'unexpectedClassesGroupOrder'
+      | 'unexpectedClassesOrder',
       SortClassesOptions,
       unknown,
       RuleListener
@@ -400,7 +415,10 @@ declare const _default: {
       'unexpectedExportsOrder',
       [
         Partial<{
+          groupKind: 'values-first' | 'types-first' | 'mixed'
           type: 'alphabetical' | 'line-length' | 'natural'
+          partitionByComment: string[] | boolean | string
+          partitionByNewLine: boolean
           order: 'desc' | 'asc'
           ignoreCase: boolean
         }>,
@@ -409,7 +427,9 @@ declare const _default: {
       RuleListener
     >
     'sort-objects': RuleModule<
-      'unexpectedObjectsGroupOrder' | 'unexpectedObjectsOrder',
+      | 'unexpectedObjectsDependencyOrder'
+      | 'unexpectedObjectsGroupOrder'
+      | 'unexpectedObjectsOrder',
       [
         Partial<{
           customGroups: {
@@ -430,7 +450,7 @@ declare const _default: {
       RuleListener
     >
     'sort-enums': RuleModule<
-      'unexpectedEnumsOrder',
+      'unexpectedEnumsDependencyOrder' | 'unexpectedEnumsOrder',
       Options_2,
       unknown,
       RuleListener
@@ -446,6 +466,8 @@ declare const _default: {
       [
         Partial<{
           type: 'alphabetical' | 'line-length' | 'natural'
+          partitionByComment: string[] | boolean | string
+          partitionByNewLine: boolean
           order: 'desc' | 'asc'
           ignoreCase: boolean
         }>,
@@ -511,6 +533,8 @@ declare type Options = [
   Partial<{
     groupKind: 'literals-first' | 'spreads-first' | 'mixed'
     type: 'alphabetical' | 'line-length' | 'natural'
+    partitionByComment: string[] | boolean | string
+    partitionByNewLine: boolean
     order: 'desc' | 'asc'
     ignoreCase: boolean
   }>,
@@ -520,6 +544,7 @@ declare type Options_2 = [
   Partial<{
     type: 'alphabetical' | 'line-length' | 'natural'
     partitionByComment: string[] | boolean | string
+    partitionByNewLine: boolean
     forceNumericSort: boolean
     order: 'desc' | 'asc'
     sortByValue: boolean

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

@@ -3,7 +3,10 @@ Object.defineProperties(exports, {
   __esModule: { value: true },
   [Symbol.toStringTag]: { value: 'Module' },
 })
+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 getLinesBetween = require('../utils/get-lines-between.js')
 const getGroupNumber = require('../utils/get-group-number.js')
 const getSourceCode = require('../utils/get-source-code.js')
 const toSingleLine = require('../utils/to-single-line.js')
@@ -38,6 +41,29 @@ let jsonSchema = {
       enum: ['mixed', 'literals-first', 'spreads-first'],
       type: 'string',
     },
+    partitionByComment: {
+      description:
+        'Allows you to use comments to separate the array members into logical groups.',
+      anyOf: [
+        {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+        },
+        {
+          type: 'boolean',
+        },
+        {
+          type: 'string',
+        },
+      ],
+    },
+    partitionByNewLine: {
+      description:
+        'Allows to use spaces to separate the nodes into logical groups.',
+      type: 'boolean',
+    },
   },
   additionalProperties: false,
 }
@@ -61,6 +87,8 @@ const sortArrayIncludes = createEslintRule.createEslintRule({
       order: 'asc',
       ignoreCase: true,
       groupKind: 'literals-first',
+      partitionByComment: false,
+      partitionByNewLine: false,
     },
   ],
   create: context => ({
@@ -88,69 +116,99 @@ let sortArray = (context, messageId, elements) => {
       type: 'alphabetical',
       ignoreCase: true,
       order: 'asc',
+      partitionByComment: false,
+      partitionByNewLine: false,
     })
     let sourceCode = getSourceCode.getSourceCode(context)
-    let nodes = elements
-      .reduce(
-        (accumulator, element) => {
-          if (element !== null) {
-            let group = 'unknown'
-            if (typeof options.groupKind === 'string') {
-              group = element.type === 'SpreadElement' ? 'spread' : 'literal'
-            }
-            accumulator.at(0).push({
-              name:
-                element.type === 'Literal'
-                  ? `${element.value}`
-                  : sourceCode.text.slice(...element.range),
-              size: rangeToDiff.rangeToDiff(element.range),
-              type: element.type,
-              node: element,
-              group,
-            })
+    let partitionComment = options.partitionByComment
+    let formattedMembers = elements.reduce(
+      (accumulator, element) => {
+        var _a
+        if (element !== null) {
+          let group = 'unknown'
+          if (typeof options.groupKind === 'string') {
+            group = element.type === 'SpreadElement' ? 'spread' : 'literal'
           }
-          return accumulator
-        },
-        [[], []],
-      )
-      .flat()
-    pairwise.pairwise(nodes, (left, right) => {
-      let groupKindOrder = ['unknown']
-      if (typeof options.groupKind === 'string') {
-        groupKindOrder =
-          options.groupKind === 'literals-first'
-            ? ['literal', 'spread']
-            : ['spread', 'literal']
-      }
-      let leftNum = getGroupNumber.getGroupNumber(groupKindOrder, left)
-      let rightNum = getGroupNumber.getGroupNumber(groupKindOrder, right)
-      if (
-        (options.groupKind !== 'mixed' && leftNum > rightNum) ||
-        ((options.groupKind === 'mixed' || leftNum === rightNum) &&
-          isPositive.isPositive(compare.compare(left, right, options)))
-      ) {
-        context.report({
-          messageId,
-          data: {
-            left: toSingleLine.toSingleLine(left.name),
-            right: toSingleLine.toSingleLine(right.name),
-          },
-          node: right.node,
-          fix: fixer => {
-            let sortedNodes =
-              options.groupKind !== 'mixed'
-                ? groupKindOrder
-                    .map(group => nodes.filter(n => n.group === group))
-                    .map(groupedNodes =>
-                      sortNodes.sortNodes(groupedNodes, options),
-                    )
-                    .flat()
-                : sortNodes.sortNodes(nodes, options)
-            return makeFixes.makeFixes(fixer, nodes, sortedNodes, sourceCode)
-          },
-        })
-      }
-    })
+          let lastSortingNode =
+            (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1)
+          let sortingNode = {
+            name:
+              element.type === 'Literal'
+                ? `${element.value}`
+                : sourceCode.text.slice(...element.range),
+            size: rangeToDiff.rangeToDiff(element.range),
+            node: element,
+            group,
+          }
+          if (
+            (partitionComment &&
+              isPartitionComment.hasPartitionComment(
+                partitionComment,
+                getCommentsBefore.getCommentsBefore(element, sourceCode),
+              )) ||
+            (options.partitionByNewLine &&
+              lastSortingNode &&
+              getLinesBetween.getLinesBetween(
+                sourceCode,
+                lastSortingNode,
+                sortingNode,
+              ))
+          ) {
+            accumulator.push([])
+          }
+          accumulator.at(-1).push(sortingNode)
+        }
+        return accumulator
+      },
+      [[]],
+    )
+    for (let nodes of formattedMembers) {
+      pairwise.pairwise(nodes, (left, right) => {
+        let groupKindOrder = ['unknown']
+        if (typeof options.groupKind === 'string') {
+          groupKindOrder =
+            options.groupKind === 'literals-first'
+              ? ['literal', 'spread']
+              : ['spread', 'literal']
+        }
+        let leftNum = getGroupNumber.getGroupNumber(groupKindOrder, left)
+        let rightNum = getGroupNumber.getGroupNumber(groupKindOrder, right)
+        if (
+          (options.groupKind !== 'mixed' && leftNum > rightNum) ||
+          ((options.groupKind === 'mixed' || leftNum === rightNum) &&
+            isPositive.isPositive(compare.compare(left, right, options)))
+        ) {
+          context.report({
+            messageId,
+            data: {
+              left: toSingleLine.toSingleLine(left.name),
+              right: toSingleLine.toSingleLine(right.name),
+            },
+            node: right.node,
+            fix: fixer => {
+              let sortedNodes =
+                options.groupKind !== 'mixed'
+                  ? groupKindOrder
+                      .map(group => nodes.filter(n => n.group === group))
+                      .map(groupedNodes =>
+                        sortNodes.sortNodes(groupedNodes, options),
+                      )
+                      .flat()
+                  : sortNodes.sortNodes(nodes, options)
+              return makeFixes.makeFixes(
+                fixer,
+                nodes,
+                sortedNodes,
+                sourceCode,
+                {
+                  partitionComment,
+                },
+              )
+            },
+          })
+        }
+      })
+    }
   }
 }
 exports.default = sortArrayIncludes

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

@@ -1,4 +1,7 @@
+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'
 import { getSourceCode } from '../utils/get-source-code.mjs'
 import { toSingleLine } from '../utils/to-single-line.mjs'
@@ -33,6 +36,29 @@ let jsonSchema = {
       enum: ['mixed', 'literals-first', 'spreads-first'],
       type: 'string',
     },
+    partitionByComment: {
+      description:
+        'Allows you to use comments to separate the array members into logical groups.',
+      anyOf: [
+        {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+        },
+        {
+          type: 'boolean',
+        },
+        {
+          type: 'string',
+        },
+      ],
+    },
+    partitionByNewLine: {
+      description:
+        'Allows to use spaces to separate the nodes into logical groups.',
+      type: 'boolean',
+    },
   },
   additionalProperties: false,
 }
@@ -56,6 +82,8 @@ const sortArrayIncludes = createEslintRule({
       order: 'asc',
       ignoreCase: true,
       groupKind: 'literals-first',
+      partitionByComment: false,
+      partitionByNewLine: false,
     },
   ],
   create: context => ({
@@ -83,67 +111,87 @@ let sortArray = (context, messageId, elements) => {
       type: 'alphabetical',
       ignoreCase: true,
       order: 'asc',
+      partitionByComment: false,
+      partitionByNewLine: false,
     })
     let sourceCode = getSourceCode(context)
-    let nodes = elements
-      .reduce(
-        (accumulator, element) => {
-          if (element !== null) {
-            let group = 'unknown'
-            if (typeof options.groupKind === 'string') {
-              group = element.type === 'SpreadElement' ? 'spread' : 'literal'
-            }
-            accumulator.at(0).push({
-              name:
-                element.type === 'Literal'
-                  ? `${element.value}`
-                  : sourceCode.text.slice(...element.range),
-              size: rangeToDiff(element.range),
-              type: element.type,
-              node: element,
-              group,
-            })
+    let partitionComment = options.partitionByComment
+    let formattedMembers = elements.reduce(
+      (accumulator, element) => {
+        var _a
+        if (element !== null) {
+          let group = 'unknown'
+          if (typeof options.groupKind === 'string') {
+            group = element.type === 'SpreadElement' ? 'spread' : 'literal'
           }
-          return accumulator
-        },
-        [[], []],
-      )
-      .flat()
-    pairwise(nodes, (left, right) => {
-      let groupKindOrder = ['unknown']
-      if (typeof options.groupKind === 'string') {
-        groupKindOrder =
-          options.groupKind === 'literals-first'
-            ? ['literal', 'spread']
-            : ['spread', 'literal']
-      }
-      let leftNum = getGroupNumber(groupKindOrder, left)
-      let rightNum = getGroupNumber(groupKindOrder, right)
-      if (
-        (options.groupKind !== 'mixed' && leftNum > rightNum) ||
-        ((options.groupKind === 'mixed' || leftNum === rightNum) &&
-          isPositive(compare(left, right, options)))
-      ) {
-        context.report({
-          messageId,
-          data: {
-            left: toSingleLine(left.name),
-            right: toSingleLine(right.name),
-          },
-          node: right.node,
-          fix: fixer => {
-            let sortedNodes =
-              options.groupKind !== 'mixed'
-                ? groupKindOrder
-                    .map(group => nodes.filter(n => n.group === group))
-                    .map(groupedNodes => sortNodes(groupedNodes, options))
-                    .flat()
-                : sortNodes(nodes, options)
-            return makeFixes(fixer, nodes, sortedNodes, sourceCode)
-          },
-        })
-      }
-    })
+          let lastSortingNode =
+            (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1)
+          let sortingNode = {
+            name:
+              element.type === 'Literal'
+                ? `${element.value}`
+                : sourceCode.text.slice(...element.range),
+            size: rangeToDiff(element.range),
+            node: element,
+            group,
+          }
+          if (
+            (partitionComment &&
+              hasPartitionComment(
+                partitionComment,
+                getCommentsBefore(element, sourceCode),
+              )) ||
+            (options.partitionByNewLine &&
+              lastSortingNode &&
+              getLinesBetween(sourceCode, lastSortingNode, sortingNode))
+          ) {
+            accumulator.push([])
+          }
+          accumulator.at(-1).push(sortingNode)
+        }
+        return accumulator
+      },
+      [[]],
+    )
+    for (let nodes of formattedMembers) {
+      pairwise(nodes, (left, right) => {
+        let groupKindOrder = ['unknown']
+        if (typeof options.groupKind === 'string') {
+          groupKindOrder =
+            options.groupKind === 'literals-first'
+              ? ['literal', 'spread']
+              : ['spread', 'literal']
+        }
+        let leftNum = getGroupNumber(groupKindOrder, left)
+        let rightNum = getGroupNumber(groupKindOrder, right)
+        if (
+          (options.groupKind !== 'mixed' && leftNum > rightNum) ||
+          ((options.groupKind === 'mixed' || leftNum === rightNum) &&
+            isPositive(compare(left, right, options)))
+        ) {
+          context.report({
+            messageId,
+            data: {
+              left: toSingleLine(left.name),
+              right: toSingleLine(right.name),
+            },
+            node: right.node,
+            fix: fixer => {
+              let sortedNodes =
+                options.groupKind !== 'mixed'
+                  ? groupKindOrder
+                      .map(group => nodes.filter(n => n.group === group))
+                      .map(groupedNodes => sortNodes(groupedNodes, options))
+                      .flat()
+                  : sortNodes(nodes, options)
+              return makeFixes(fixer, nodes, sortedNodes, sourceCode, {
+                partitionComment,
+              })
+            },
+          })
+        }
+      })
+    }
   }
 }
 export { sortArrayIncludes as default, jsonSchema, sortArray }

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: {
@@ -152,17 +150,22 @@ 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:
                     leftNum !== rightNum
@@ -175,37 +178,8 @@ const sortAstroAttributes = createEslintRule.createEslintRule({
                     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),
                 })
               }
             })