eslint-plugin-perfectionist 4.0.2 → 4.1.0

package/dist/rules/sort-decorators.js

@@ -6,6 +6,7 @@ const isNodeEslintDisabled = require('../utils/is-node-eslint-disabled.js')
 const isPartitionComment = require('../utils/is-partition-comment.js')
 const sortNodesByGroups = require('../utils/sort-nodes-by-groups.js')
 const getCommentsBefore = require('../utils/get-comments-before.js')
+const getNodeDecorators = require('../utils/get-node-decorators.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const getDecoratorName = require('../utils/get-decorator-name.js')
 const getGroupNumber = require('../utils/get-group-number.js')
@@ -125,19 +126,35 @@ const sortDecorators = createEslintRule.createEslintRule({
       },
       PropertyDefinition: propertyDefinition =>
         options.sortOnProperties
-          ? sortDecorators$1(context, options, propertyDefinition.decorators)
+          ? sortDecorators$1(
+              context,
+              options,
+              getNodeDecorators.getNodeDecorators(propertyDefinition),
+            )
           : null,
       AccessorProperty: accessorDefinition =>
         options.sortOnAccessors
-          ? sortDecorators$1(context, options, accessorDefinition.decorators)
+          ? sortDecorators$1(
+              context,
+              options,
+              getNodeDecorators.getNodeDecorators(accessorDefinition),
+            )
           : null,
       MethodDefinition: methodDefinition =>
         options.sortOnMethods
-          ? sortDecorators$1(context, options, methodDefinition.decorators)
+          ? sortDecorators$1(
+              context,
+              options,
+              getNodeDecorators.getNodeDecorators(methodDefinition),
+            )
           : null,
-      ClassDeclaration: Declaration =>
+      ClassDeclaration: declaration =>
         options.sortOnClasses
-          ? sortDecorators$1(context, options, Declaration.decorators)
+          ? sortDecorators$1(
+              context,
+              options,
+              getNodeDecorators.getNodeDecorators(declaration),
+            )
           : null,
     }
   },

package/dist/rules/sort-enums.js

@@ -7,6 +7,7 @@ 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 getEnumMembers = require('../utils/get-enum-members.js')
 const getSourceCode = require('../utils/get-source-code.js')
 const toSingleLine = require('../utils/to-single-line.js')
 const rangeToDiff = require('../utils/range-to-diff.js')
@@ -29,8 +30,8 @@ let defaultOptions = {
 }
 const sortEnums = createEslintRule.createEslintRule({
   create: context => ({
-    TSEnumDeclaration: node => {
-      let members = node.body.members ?? node.members ?? []
+    TSEnumDeclaration: enumDeclaration => {
+      let members = getEnumMembers.getEnumMembers(enumDeclaration)
       if (
         !isSortable.isSortable(members) ||
         !members.every(({ initializer }) => initializer)
@@ -81,11 +82,17 @@ const sortEnums = createEslintRule.createEslintRule({
           var _a
           let dependencies = []
           if (member.initializer) {
-            dependencies = extractDependencies(member.initializer, node.id.name)
+            dependencies = extractDependencies(
+              member.initializer,
+              enumDeclaration.id.name,
+            )
           }
           let lastSortingNode =
             (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1)
           let sortingNode = {
+            numericValue: member.initializer
+              ? getExpressionNumberValue(member.initializer)
+              : null,
             name:
               member.id.type === 'Literal'
                 ? `${member.id.value}`
@@ -119,21 +126,22 @@ const sortEnums = createEslintRule.createEslintRule({
         },
         [[]],
       )
-      let isNumericEnum = members.every(member => {
-        var _a
-        return (
-          ((_a = member.initializer) == null ? void 0 : _a.type) ===
-            'Literal' && typeof member.initializer.value === 'number'
-        )
-      })
+      let sortingNodes = formattedMembers.flat()
+      let isNumericEnum = sortingNodes.every(
+        sortingNode =>
+          sortingNode.numericValue !== null &&
+          !Number.isNaN(sortingNode.numericValue),
+      )
       let compareOptions = {
         // Get the enum value rather than the name if needed
         nodeValueGetter:
           options.sortByValue || (isNumericEnum && options.forceNumericSort)
             ? sortingNode => {
                 var _a, _b
+                if (isNumericEnum) {
+                  return sortingNode.numericValue.toString()
+                }
                 if (
-                  sortingNode.node.type === 'TSEnumMember' &&
                   ((_a = sortingNode.node.initializer) == null
                     ? void 0
                     : _a.type) === 'Literal'
@@ -159,8 +167,8 @@ const sortEnums = createEslintRule.createEslintRule({
       }
       let sortNodesIgnoringEslintDisabledNodes = ignoreEslintDisabledNodes =>
         sortNodesByDependencies.sortNodesByDependencies(
-          formattedMembers.flatMap(nodes2 =>
-            sortNodes.sortNodes(nodes2, compareOptions, {
+          formattedMembers.flatMap(nodes =>
+            sortNodes.sortNodes(nodes, compareOptions, {
               ignoreEslintDisabledNodes,
             }),
           ),
@@ -171,8 +179,7 @@ const sortEnums = createEslintRule.createEslintRule({
       let sortedNodes = sortNodesIgnoringEslintDisabledNodes(false)
       let sortedNodesExcludingEslintDisabled =
         sortNodesIgnoringEslintDisabledNodes(true)
-      let nodes = formattedMembers.flat()
-      pairwise.pairwise(nodes, (left, right) => {
+      pairwise.pairwise(sortingNodes, (left, right) => {
         let indexOfLeft = sortedNodes.indexOf(left)
         let indexOfRight = sortedNodes.indexOf(right)
         let indexOfRightExcludingEslintDisabled =
@@ -184,15 +191,18 @@ const sortEnums = createEslintRule.createEslintRule({
           return
         }
         let firstUnorderedNodeDependentOnRight =
-          sortNodesByDependencies.getFirstUnorderedNodeDependentOn(right, nodes)
+          sortNodesByDependencies.getFirstUnorderedNodeDependentOn(
+            right,
+            sortingNodes,
+          )
         context.report({
           fix: fixer =>
             makeFixes.makeFixes({
               sortedNodes: sortedNodesExcludingEslintDisabled,
+              nodes: sortingNodes,
               sourceCode,
               options,
               fixer,
-              nodes,
             }),
           data: {
             nodeDependentOnRight:
@@ -255,4 +265,72 @@ const sortEnums = createEslintRule.createEslintRule({
   defaultOptions: [defaultOptions],
   name: 'sort-enums',
 })
+let getExpressionNumberValue = expression => {
+  switch (expression.type) {
+    case 'BinaryExpression':
+      return getBinaryExpressionNumberValue(
+        expression.left,
+        expression.right,
+        expression.operator,
+      )
+    case 'UnaryExpression':
+      return getUnaryExpressionNumberValue(
+        expression.argument,
+        expression.operator,
+      )
+    case 'Literal':
+      return typeof expression.value === 'number'
+        ? expression.value
+        : Number.NaN
+    default:
+      return Number.NaN
+  }
+}
+let getUnaryExpressionNumberValue = (argumentExpression, operator) => {
+  let argument = getExpressionNumberValue(argumentExpression)
+  switch (operator) {
+    case '+':
+      return argument
+    case '-':
+      return -argument
+    case '~':
+      return ~argument
+    default:
+      return Number.NaN
+  }
+}
+let getBinaryExpressionNumberValue = (
+  leftExpression,
+  rightExpression,
+  operator,
+) => {
+  let left = getExpressionNumberValue(leftExpression)
+  let right = getExpressionNumberValue(rightExpression)
+  switch (operator) {
+    case '**':
+      return left ** right
+    case '>>':
+      return left >> right
+    case '<<':
+      return left << right
+    case '+':
+      return left + right
+    case '-':
+      return left - right
+    case '*':
+      return left * right
+    case '/':
+      return left / right
+    case '%':
+      return left % right
+    case '|':
+      return left | right
+    case '&':
+      return left & right
+    case '^':
+      return left ^ right
+    default:
+      return Number.NaN
+  }
+}
 module.exports = sortEnums

package/dist/rules/sort-heritage-clauses.js

@@ -78,7 +78,7 @@ const sortHeritageClauses = createEslintRule.createEslintRule({
   name: 'sort-heritage-clauses',
 })
 let sortHeritageClauses$1 = (context, options, heritageClauses) => {
-  if (!isSortable.isSortable(heritageClauses)) {
+  if (!heritageClauses || !isSortable.isSortable(heritageClauses)) {
     return
   }
   let sourceCode = getSourceCode.getSourceCode(context)

package/dist/rules/sort-modules.js

@@ -14,9 +14,11 @@ const sortNodesByGroups = require('../utils/sort-nodes-by-groups.js')
 const getNewlinesErrors = require('../utils/get-newlines-errors.js')
 const makeNewlinesFixes = require('../utils/make-newlines-fixes.js')
 const getCommentsBefore = require('../utils/get-comments-before.js')
+const getNodeDecorators = require('../utils/get-node-decorators.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 getEnumMembers = require('../utils/get-enum-members.js')
 const getSourceCode = require('../utils/get-source-code.js')
 const toSingleLine = require('../utils/to-single-line.js')
 const rangeToDiff = require('../utils/range-to-diff.js')
@@ -239,16 +241,19 @@ let analyzeModule = ({
           ;({ name } = nodeToParse.id)
           dependencies = [
             ...dependencies,
-            ...extractDependencies(nodeToParse.body),
+            ...getEnumMembers
+              .getEnumMembers(nodeToParse)
+              .flatMap(extractDependencies),
           ]
           break
         case utils.AST_NODE_TYPES.ClassDeclaration:
           selector = 'class'
           name = (_b2 = nodeToParse.id) == null ? void 0 : _b2.name
-          if (nodeToParse.decorators.length > 0) {
+          let nodeDecorators = getNodeDecorators.getNodeDecorators(nodeToParse)
+          if (nodeDecorators.length > 0) {
             modifiers.push('decorated')
           }
-          for (let decorator of nodeToParse.decorators) {
+          for (let decorator of nodeDecorators) {
             if (decorator.expression.type === 'Identifier') {
               decorators.push(decorator.expression.name)
             } else if (
@@ -493,9 +498,6 @@ let extractDependencies = expression => {
     if ('right' in nodeValue) {
       checkNode(nodeValue.right)
     }
-    if ('members' in nodeValue) {
-      traverseNode(nodeValue.members)
-    }
     if ('initializer' in nodeValue && nodeValue.initializer) {
       checkNode(nodeValue.initializer)
     }

package/dist/rules/sort-objects.js

@@ -20,6 +20,7 @@ const getSettings = require('../utils/get-settings.js')
 const isSortable = require('../utils/is-sortable.js')
 const useGroups = require('../utils/use-groups.js')
 const makeFixes = require('../utils/make-fixes.js')
+const sortNodes = require('../utils/sort-nodes.js')
 const complete = require('../utils/complete.js')
 const pairwise = require('../utils/pairwise.js')
 const matches = require('../utils/matches.js')
@@ -28,6 +29,8 @@ let defaultOptions = {
   partitionByComment: false,
   newlinesBetween: 'ignore',
   specialCharacters: 'keep',
+  destructuredObjects: true,
+  objectDeclarations: true,
   styledComponents: true,
   destructureOnly: false,
   type: 'alphabetical',
@@ -40,7 +43,10 @@ let defaultOptions = {
 }
 const sortObjects = createEslintRule.createEslintRule({
   create: context => {
-    let sortObject = node => {
+    let sortObject = nodeObject => {
+      if (!isSortable.isSortable(nodeObject.properties)) {
+        return
+      }
       let settings = getSettings.getSettings(context.settings)
       let options = complete.complete(
         context.options.at(0),
@@ -55,12 +61,16 @@ const sortObjects = createEslintRule.createEslintRule({
       validateNewlinesAndPartitionConfiguration.validateNewlinesAndPartitionConfiguration(
         options,
       )
-      let shouldIgnore = false
-      if (options.destructureOnly) {
-        shouldIgnore = node.type !== 'ObjectPattern'
+      let isDestructuredObject = nodeObject.type === 'ObjectPattern'
+      if (isDestructuredObject) {
+        if (!options.destructuredObjects) {
+          return
+        }
+      } else if (options.destructureOnly || !options.objectDeclarations) {
+        return
       }
-      if (!shouldIgnore && options.ignorePattern.length) {
-        let variableParent = getNodeParent.getNodeParent(node, [
+      if (options.ignorePattern.length) {
+        let variableParent = getNodeParent.getNodeParent(nodeObject, [
           'VariableDeclarator',
           'Property',
         ])
@@ -83,21 +93,20 @@ const sortObjects = createEslintRule.createEslintRule({
           typeof variableIdentifier === 'string' &&
           checkMatch(variableIdentifier)
         ) {
-          shouldIgnore = true
+          return
         }
-        let callParent = getNodeParent.getNodeParent(node, ['CallExpression'])
+        let callParent = getNodeParent.getNodeParent(nodeObject, [
+          'CallExpression',
+        ])
         let callIdentifier =
           (callParent == null ? void 0 : callParent.type) ===
             'CallExpression' && callParent.callee.type === 'Identifier'
             ? callParent.callee.name
             : null
         if (callIdentifier && checkMatch(callIdentifier)) {
-          shouldIgnore = true
+          return
         }
       }
-      if (shouldIgnore || !isSortable.isSortable(node.properties)) {
-        return
-      }
       let isStyledCallExpression = identifier =>
         identifier.type === 'Identifier' && identifier.name === 'styled'
       let isCssCallExpression = identifier =>
@@ -115,9 +124,9 @@ const sortObjects = createEslintRule.createEslintRule({
             styledNode.parent.name.name === 'style'))
       if (
         !options.styledComponents &&
-        (isStyledComponents(node.parent) ||
-          (node.parent.type === 'ArrowFunctionExpression' &&
-            isStyledComponents(node.parent.parent)))
+        (isStyledComponents(nodeObject.parent) ||
+          (nodeObject.parent.type === 'ArrowFunctionExpression' &&
+            isStyledComponents(nodeObject.parent.parent)))
       ) {
         return
       }
@@ -271,11 +280,17 @@ const sortObjects = createEslintRule.createEslintRule({
           },
           [[]],
         )
-      let formattedMembers = formatProperties(node.properties)
+      let formattedMembers = formatProperties(nodeObject.properties)
+      let nodesSortingFunction =
+        isDestructuredObject &&
+        typeof options.destructuredObjects === 'object' &&
+        !options.destructuredObjects.groups
+          ? sortNodes.sortNodes
+          : sortNodesByGroups.sortNodesByGroups
       let sortNodesIgnoringEslintDisabledNodes = ignoreEslintDisabledNodes =>
         sortNodesByDependencies.sortNodesByDependencies(
           formattedMembers.flatMap(nodes2 =>
-            sortNodesByGroups.sortNodesByGroups(nodes2, options, {
+            nodesSortingFunction(nodes2, options, {
               ignoreEslintDisabledNodes,
             }),
           ),
@@ -371,6 +386,25 @@ const sortObjects = createEslintRule.createEslintRule({
     schema: [
       {
         properties: {
+          destructuredObjects: {
+            oneOf: [
+              {
+                type: 'boolean',
+              },
+              {
+                properties: {
+                  groups: {
+                    description:
+                      'Controls whether to use groups to sort destructured objects.',
+                    type: 'boolean',
+                  },
+                },
+                additionalProperties: false,
+                type: 'object',
+              },
+            ],
+            description: 'Controls whether to sort destructured objects.',
+          },
           ignorePattern: {
             description:
               'Specifies names or patterns for nodes that should be ignored by rule.',
@@ -388,6 +422,10 @@ const sortObjects = createEslintRule.createEslintRule({
             description: 'Controls whether to sort only destructured objects.',
             type: 'boolean',
           },
+          objectDeclarations: {
+            description: 'Controls whether to sort object declarations.',
+            type: 'boolean',
+          },
           styledComponents: {
             description: 'Controls whether to sort styled components.',
             type: 'boolean',

package/dist/utils/get-enum-members.js

@@ -0,0 +1,7 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+let getEnumMembers = value => {
+  var _a
+  return ((_a = value.body) == null ? void 0 : _a.members) ?? value.members
+}
+exports.getEnumMembers = getEnumMembers

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

@@ -0,0 +1,4 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+let getNodeDecorators = node => node.decorators ?? []
+exports.getNodeDecorators = getNodeDecorators

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-perfectionist",
-  "version": "4.0.2",
+  "version": "4.1.0",
   "description": "ESLint plugin for sorting various data such as objects, imports, types, enums, JSX props, etc.",
   "keywords": [
     "eslint",
@@ -23,8 +23,8 @@
     "./dist"
   ],
   "dependencies": {
-    "@typescript-eslint/types": "^8.15.0",
-    "@typescript-eslint/utils": "^8.15.0",
+    "@typescript-eslint/types": "^8.16.0",
+    "@typescript-eslint/utils": "^8.16.0",
     "natural-orderby": "^5.0.0"
   },
   "peerDependencies": {