eslint-plugin-perfectionist 4.0.3 → 4.1.1

package/dist/rules/sort-enums.js

@@ -30,8 +30,8 @@ let defaultOptions = {
 }
 const sortEnums = createEslintRule.createEslintRule({
   create: context => ({
-    TSEnumDeclaration: node => {
-      let members = getEnumMembers.getEnumMembers(node)
+    TSEnumDeclaration: enumDeclaration => {
+      let members = getEnumMembers.getEnumMembers(enumDeclaration)
       if (
         !isSortable.isSortable(members) ||
         !members.every(({ initializer }) => initializer)
@@ -82,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}`
@@ -120,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'
@@ -160,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,
             }),
           ),
@@ -172,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 =
@@ -185,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:
@@ -256,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-modules.js

@@ -1,5 +1,6 @@
 'use strict'
 const utils = require('@typescript-eslint/utils')
+const isSortable = require('utils/is-sortable')
 const commonJsonSchemas = require('../utils/common-json-schemas.js')
 const sortModules_types = require('./sort-modules.types.js')
 const sortNodesByDependencies = require('../utils/sort-nodes-by-dependencies.js')
@@ -155,14 +156,17 @@ const sortModules = createEslintRule.createEslintRule({
       sourceCode,
     })
     return {
-      Program: program =>
-        analyzeModule({
-          eslintDisabledLines,
-          sourceCode,
-          options,
-          program,
-          context,
-        }),
+      Program: program => {
+        if (isSortable.isSortable(program.body)) {
+          return analyzeModule({
+            eslintDisabledLines,
+            sourceCode,
+            options,
+            program,
+            context,
+          })
+        }
+      },
     }
   },
   defaultOptions: [defaultOptions],

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/is-sortable.js

@@ -1,4 +1,4 @@
 'use strict'
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
-let isSortable = array => array.length > 1
+let isSortable = node => Array.isArray(node) && node.length > 1
 exports.isSortable = isSortable

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-perfectionist",
-  "version": "4.0.3",
+  "version": "4.1.1",
   "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": {