eslint-plugin-perfectionist 3.0.0 → 3.1.0

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

@@ -1,6 +1,5 @@
 'use strict'
 const minimatch = require('minimatch')
-const path = require('node:path')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const getGroupNumber = require('../utils/get-group-number.js')
 const getSourceCode = require('../utils/get-source-code.js')
@@ -101,127 +100,113 @@ const sortJsxProps = createEslintRule.createEslintRule({
       customGroups: {},
     },
   ],
-  create: context => {
-    if (
-      ['.svelte', '.astro', '.vue'].includes(path.extname(context.filename))
-    ) {
-      return {}
-    }
-    return {
-      JSXElement: node => {
-        if (node.openingElement.attributes.length > 1) {
-          let options = complete.complete(context.options.at(0), {
-            type: 'alphabetical',
-            ignorePattern: [],
-            ignoreCase: true,
-            customGroups: {},
-            order: 'asc',
-            groups: [],
-          })
-          let sourceCode = getSourceCode.getSourceCode(context)
-          let shouldIgnore = false
-          if (options.ignorePattern.length) {
-            let tagName = sourceCode.text.slice(
-              ...node.openingElement.name.range,
-            )
-            shouldIgnore = options.ignorePattern.some(pattern =>
-              minimatch.minimatch(tagName, pattern),
-            )
-          }
-          if (!shouldIgnore && node.openingElement.attributes.length > 1) {
-            let parts = node.openingElement.attributes.reduce(
-              (accumulator, attribute) => {
-                if (attribute.type === 'JSXSpreadAttribute') {
-                  accumulator.push([])
-                  return accumulator
-                }
-                let name =
-                  attribute.name.type === 'JSXNamespacedName'
-                    ? `${attribute.name.namespace.name}:${attribute.name.name.name}`
-                    : attribute.name.name
-                let { getGroup, defineGroup, setCustomGroups } =
-                  useGroups.useGroups(options.groups)
-                setCustomGroups(options.customGroups, name)
-                if (attribute.value === null) {
-                  defineGroup('shorthand')
-                }
-                if (attribute.loc.start.line !== attribute.loc.end.line) {
-                  defineGroup('multiline')
-                }
-                let jsxNode = {
-                  size: rangeToDiff.rangeToDiff(attribute.range),
-                  group: getGroup(),
-                  node: attribute,
-                  name,
-                }
-                accumulator.at(-1).push(jsxNode)
+  create: context => ({
+    JSXElement: node => {
+      if (node.openingElement.attributes.length > 1) {
+        let options = complete.complete(context.options.at(0), {
+          type: 'alphabetical',
+          ignorePattern: [],
+          ignoreCase: true,
+          customGroups: {},
+          order: 'asc',
+          groups: [],
+        })
+        let sourceCode = getSourceCode.getSourceCode(context)
+        let shouldIgnore = false
+        if (options.ignorePattern.length) {
+          let tagName = sourceCode.text.slice(...node.openingElement.name.range)
+          shouldIgnore = options.ignorePattern.some(pattern =>
+            minimatch.minimatch(tagName, pattern),
+          )
+        }
+        if (!shouldIgnore && node.openingElement.attributes.length > 1) {
+          let parts = node.openingElement.attributes.reduce(
+            (accumulator, attribute) => {
+              if (attribute.type === 'JSXSpreadAttribute') {
+                accumulator.push([])
                 return accumulator
-              },
-              [[]],
-            )
-            for (let nodes of parts) {
-              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),
-                    ))
-                ) {
-                  context.report({
-                    messageId: 'unexpectedJSXPropsOrder',
-                    data: {
-                      left: left.name,
-                      right: right.name,
-                    },
-                    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),
+              }
+              let name =
+                attribute.name.type === 'JSXNamespacedName'
+                  ? `${attribute.name.namespace.name}:${attribute.name.name.name}`
+                  : attribute.name.name
+              let { getGroup, defineGroup, setCustomGroups } =
+                useGroups.useGroups(options.groups)
+              setCustomGroups(options.customGroups, name)
+              if (attribute.value === null) {
+                defineGroup('shorthand')
+              }
+              if (attribute.loc.start.line !== attribute.loc.end.line) {
+                defineGroup('multiline')
+              }
+              let jsxNode = {
+                size: rangeToDiff.rangeToDiff(attribute.range),
+                node: structuredClone(attribute),
+                group: getGroup(),
+                name,
+              }
+              accumulator.at(-1).push(jsxNode)
+              return accumulator
+            },
+            [[]],
+          )
+          for (let nodes of parts) {
+            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)))
+              ) {
+                context.report({
+                  messageId: 'unexpectedJSXPropsOrder',
+                  data: {
+                    left: left.name,
+                    right: right.name,
+                  },
+                  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,
                         )
                       }
-                      return makeFixes.makeFixes(
-                        fixer,
-                        nodes,
-                        sortedNodes,
-                        sourceCode,
+                    }
+                    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,
+                    )
+                  },
+                })
+              }
+            })
           }
         }
-      },
-    }
-  },
+      }
+    },
+  }),
 })
 module.exports = sortJsxProps

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

@@ -1,5 +1,4 @@
 import { minimatch } from 'minimatch'
-import path from 'node:path'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
 import { getGroupNumber } from '../utils/get-group-number.mjs'
 import { getSourceCode } from '../utils/get-source-code.mjs'
@@ -100,113 +99,101 @@ const sortJsxProps = createEslintRule({
       customGroups: {},
     },
   ],
-  create: context => {
-    if (
-      ['.svelte', '.astro', '.vue'].includes(path.extname(context.filename))
-    ) {
-      return {}
-    }
-    return {
-      JSXElement: node => {
-        if (node.openingElement.attributes.length > 1) {
-          let options = complete(context.options.at(0), {
-            type: 'alphabetical',
-            ignorePattern: [],
-            ignoreCase: true,
-            customGroups: {},
-            order: 'asc',
-            groups: [],
-          })
-          let sourceCode = getSourceCode(context)
-          let shouldIgnore = false
-          if (options.ignorePattern.length) {
-            let tagName = sourceCode.text.slice(
-              ...node.openingElement.name.range,
-            )
-            shouldIgnore = options.ignorePattern.some(pattern =>
-              minimatch(tagName, pattern),
-            )
-          }
-          if (!shouldIgnore && node.openingElement.attributes.length > 1) {
-            let parts = node.openingElement.attributes.reduce(
-              (accumulator, attribute) => {
-                if (attribute.type === 'JSXSpreadAttribute') {
-                  accumulator.push([])
-                  return accumulator
-                }
-                let name =
-                  attribute.name.type === 'JSXNamespacedName'
-                    ? `${attribute.name.namespace.name}:${attribute.name.name.name}`
-                    : attribute.name.name
-                let { getGroup, defineGroup, setCustomGroups } = useGroups(
-                  options.groups,
-                )
-                setCustomGroups(options.customGroups, name)
-                if (attribute.value === null) {
-                  defineGroup('shorthand')
-                }
-                if (attribute.loc.start.line !== attribute.loc.end.line) {
-                  defineGroup('multiline')
-                }
-                let jsxNode = {
-                  size: rangeToDiff(attribute.range),
-                  group: getGroup(),
-                  node: attribute,
-                  name,
-                }
-                accumulator.at(-1).push(jsxNode)
+  create: context => ({
+    JSXElement: node => {
+      if (node.openingElement.attributes.length > 1) {
+        let options = complete(context.options.at(0), {
+          type: 'alphabetical',
+          ignorePattern: [],
+          ignoreCase: true,
+          customGroups: {},
+          order: 'asc',
+          groups: [],
+        })
+        let sourceCode = getSourceCode(context)
+        let shouldIgnore = false
+        if (options.ignorePattern.length) {
+          let tagName = sourceCode.text.slice(...node.openingElement.name.range)
+          shouldIgnore = options.ignorePattern.some(pattern =>
+            minimatch(tagName, pattern),
+          )
+        }
+        if (!shouldIgnore && node.openingElement.attributes.length > 1) {
+          let parts = node.openingElement.attributes.reduce(
+            (accumulator, attribute) => {
+              if (attribute.type === 'JSXSpreadAttribute') {
+                accumulator.push([])
                 return accumulator
-              },
-              [[]],
-            )
-            for (let nodes of parts) {
-              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)))
-                ) {
-                  context.report({
-                    messageId: 'unexpectedJSXPropsOrder',
-                    data: {
-                      left: left.name,
-                      right: right.name,
-                    },
-                    node: right.node,
-                    fix: fixer => {
-                      let grouped = {}
-                      for (let currentNode of nodes) {
-                        let groupNum = getGroupNumber(
-                          options.groups,
-                          currentNode,
+              }
+              let name =
+                attribute.name.type === 'JSXNamespacedName'
+                  ? `${attribute.name.namespace.name}:${attribute.name.name.name}`
+                  : attribute.name.name
+              let { getGroup, defineGroup, setCustomGroups } = useGroups(
+                options.groups,
+              )
+              setCustomGroups(options.customGroups, name)
+              if (attribute.value === null) {
+                defineGroup('shorthand')
+              }
+              if (attribute.loc.start.line !== attribute.loc.end.line) {
+                defineGroup('multiline')
+              }
+              let jsxNode = {
+                size: rangeToDiff(attribute.range),
+                node: structuredClone(attribute),
+                group: getGroup(),
+                name,
+              }
+              accumulator.at(-1).push(jsxNode)
+              return accumulator
+            },
+            [[]],
+          )
+          for (let nodes of parts) {
+            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)))
+              ) {
+                context.report({
+                  messageId: 'unexpectedJSXPropsOrder',
+                  data: {
+                    left: left.name,
+                    right: right.name,
+                  },
+                  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,
                         )
-                        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)
-                    },
-                  })
-                }
-              })
-            }
+                    }
+                    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)
+                  },
+                })
+              }
+            })
           }
         }
-      },
-    }
-  },
+      }
+    },
+  }),
 })
 export { sortJsxProps as default }

package/dist/rules/sort-maps.js

@@ -99,7 +99,7 @@ const sortMaps = createEslintRule.createEslintRule({
               }
               return {
                 size: rangeToDiff.rangeToDiff(element.range),
-                node: element,
+                node: structuredClone(element),
                 name,
               }
             })

package/dist/rules/sort-maps.mjs

@@ -98,7 +98,7 @@ const sortMaps = createEslintRule({
               }
               return {
                 size: rangeToDiff(element.range),
-                node: element,
+                node: structuredClone(element),
                 name,
               }
             })

package/dist/rules/sort-named-exports.js

@@ -78,8 +78,8 @@ const sortNamedExports = createEslintRule.createEslintRule({
           }
           return {
             size: rangeToDiff.rangeToDiff(specifier.range),
+            node: structuredClone(specifier),
             name: specifier.local.name,
-            node: specifier,
             group,
           }
         })

package/dist/rules/sort-named-exports.mjs

@@ -77,8 +77,8 @@ const sortNamedExports = createEslintRule({
           }
           return {
             size: rangeToDiff(specifier.range),
+            node: structuredClone(specifier),
             name: specifier.local.name,
-            node: specifier,
             group,
           }
         })

package/dist/rules/sort-named-imports.js

@@ -94,7 +94,7 @@ const sortNamedImports = createEslintRule.createEslintRule({
           }
           return {
             size: rangeToDiff.rangeToDiff(specifier.range),
-            node: specifier,
+            node: structuredClone(specifier),
             group,
             name,
           }

package/dist/rules/sort-named-imports.mjs

@@ -93,7 +93,7 @@ const sortNamedImports = createEslintRule({
           }
           return {
             size: rangeToDiff(specifier.range),
-            node: specifier,
+            node: structuredClone(specifier),
             group,
             name,
           }

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

@@ -164,7 +164,7 @@ const sortObjectTypes = createEslintRule.createEslintRule({
             let endSize = endsWithComma ? 1 : 0
             let memberSortingNode = {
               size: rangeToDiff.rangeToDiff(member.range) - endSize,
-              node: member,
+              node: structuredClone(member),
               name,
             }
             if (

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

@@ -164,7 +164,7 @@ const sortObjectTypes = createEslintRule({
             let endSize = endsWithComma ? 1 : 0
             let memberSortingNode = {
               size: rangeToDiff(member.range) - endSize,
-              node: member,
+              node: structuredClone(member),
               name,
             }
             if (

package/dist/rules/sort-objects.js

@@ -71,6 +71,10 @@ const sortObjects = createEslintRule.createEslintRule({
             description: 'Controls whether to sort styled components.',
             type: 'boolean',
           },
+          destructureOnly: {
+            description: 'Controls whether to sort only destructured objects.',
+            type: 'boolean',
+          },
           ignorePattern: {
             description:
               'Specifies names or patterns for nodes that should be ignored by rule.',
@@ -79,10 +83,6 @@ const sortObjects = createEslintRule.createEslintRule({
             },
             type: 'array',
           },
-          customIgnore: {
-            description: 'Specifies custom ignore functions.',
-            type: 'array',
-          },
           groups: {
             description: 'Specifies the order of the groups.',
             type: 'array',
@@ -133,8 +133,8 @@ const sortObjects = createEslintRule.createEslintRule({
       partitionByComment: false,
       partitionByNewLine: false,
       styledComponents: true,
+      destructureOnly: false,
       ignorePattern: [],
-      customIgnore: [],
       groups: [],
       customGroups: {},
     },
@@ -145,20 +145,17 @@ const sortObjects = createEslintRule.createEslintRule({
         partitionByNewLine: false,
         partitionByComment: false,
         styledComponents: true,
+        destructureOnly: false,
         type: 'alphabetical',
         ignorePattern: [],
         ignoreCase: true,
         customGroups: {},
-        customIgnore: [],
         order: 'asc',
         groups: [],
       })
       let shouldIgnore = false
-      if (
-        options.customIgnore.length &&
-        options.customIgnore.some(fn => fn(node, context.filename))
-      ) {
-        shouldIgnore = true
+      if (options.destructureOnly) {
+        shouldIgnore = node.type !== 'ObjectPattern'
       }
       if (!shouldIgnore && options.ignorePattern.length) {
         let varParent = getNodeParent.getNodeParent(node, [
@@ -255,7 +252,7 @@ const sortObjects = createEslintRule.createEslintRule({
               }
               let propSortingNode = {
                 size: rangeToDiff.rangeToDiff(prop.range),
-                node: prop,
+                node: structuredClone(prop),
                 name,
               }
               if (

package/dist/rules/sort-objects.mjs

@@ -70,6 +70,10 @@ const sortObjects = createEslintRule({
             description: 'Controls whether to sort styled components.',
             type: 'boolean',
           },
+          destructureOnly: {
+            description: 'Controls whether to sort only destructured objects.',
+            type: 'boolean',
+          },
           ignorePattern: {
             description:
               'Specifies names or patterns for nodes that should be ignored by rule.',
@@ -78,10 +82,6 @@ const sortObjects = createEslintRule({
             },
             type: 'array',
           },
-          customIgnore: {
-            description: 'Specifies custom ignore functions.',
-            type: 'array',
-          },
           groups: {
             description: 'Specifies the order of the groups.',
             type: 'array',
@@ -132,8 +132,8 @@ const sortObjects = createEslintRule({
       partitionByComment: false,
       partitionByNewLine: false,
       styledComponents: true,
+      destructureOnly: false,
       ignorePattern: [],
-      customIgnore: [],
       groups: [],
       customGroups: {},
     },
@@ -144,20 +144,17 @@ const sortObjects = createEslintRule({
         partitionByNewLine: false,
         partitionByComment: false,
         styledComponents: true,
+        destructureOnly: false,
         type: 'alphabetical',
         ignorePattern: [],
         ignoreCase: true,
         customGroups: {},
-        customIgnore: [],
         order: 'asc',
         groups: [],
       })
       let shouldIgnore = false
-      if (
-        options.customIgnore.length &&
-        options.customIgnore.some(fn => fn(node, context.filename))
-      ) {
-        shouldIgnore = true
+      if (options.destructureOnly) {
+        shouldIgnore = node.type !== 'ObjectPattern'
       }
       if (!shouldIgnore && options.ignorePattern.length) {
         let varParent = getNodeParent(node, ['VariableDeclarator', 'Property'])
@@ -246,7 +243,7 @@ const sortObjects = createEslintRule({
               }
               let propSortingNode = {
                 size: rangeToDiff(prop.range),
-                node: prop,
+                node: structuredClone(prop),
                 name,
               }
               if (