eslint-plugin-perfectionist 4.9.0 → 4.10.0

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

@@ -6,10 +6,10 @@ Object.defineProperties(exports, {
 const commonJsonSchemas = require('../utils/common-json-schemas.js')
 const reportErrors = require('../utils/report-errors.js')
 const validateNewlinesAndPartitionConfiguration = require('../utils/validate-newlines-and-partition-configuration.js')
+const getCustomGroupsCompareOptions = require('../utils/get-custom-groups-compare-options.js')
 const validateGeneratedGroupsConfiguration = require('../utils/validate-generated-groups-configuration.js')
 const validateCustomSortConfiguration = require('../utils/validate-custom-sort-configuration.js')
 const types = require('./sort-array-includes/types.js')
-const getCustomGroupsCompareOptions = require('../utils/get-custom-groups-compare-options.js')
 const doesCustomGroupMatch = require('./sort-array-includes/does-custom-group-match.js')
 const getMatchingContextOptions = require('../utils/get-matching-context-options.js')
 const generatePredefinedGroups = require('../utils/generate-predefined-groups.js')
@@ -229,13 +229,14 @@ let sortArray = ({ availableMessageIds, elements, context }) => {
     )
     let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
       filteredGroupKindNodes.flatMap(groupedNodes =>
-        sortNodesByGroups.sortNodesByGroups(groupedNodes, options, {
-          getGroupCompareOptions: groupNumber =>
-            getCustomGroupsCompareOptions.getCustomGroupsCompareOptions(
+        sortNodesByGroups.sortNodesByGroups({
+          getOptionsByGroupNumber:
+            getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
               options,
-              groupNumber,
             ),
           ignoreEslintDisabledNodes,
+          groups: options.groups,
+          nodes: groupedNodes,
         }),
       )
     reportAllErrors.reportAllErrors({

package/dist/rules/sort-classes.js

@@ -2,10 +2,10 @@
 const commonJsonSchemas = require('../utils/common-json-schemas.js')
 const reportErrors = require('../utils/report-errors.js')
 const validateNewlinesAndPartitionConfiguration = require('../utils/validate-newlines-and-partition-configuration.js')
+const getCustomGroupsCompareOptions = require('../utils/get-custom-groups-compare-options.js')
 const validateGeneratedGroupsConfiguration = require('../utils/validate-generated-groups-configuration.js')
 const types = require('./sort-classes/types.js')
 const validateCustomSortConfiguration = require('../utils/validate-custom-sort-configuration.js')
-const getCustomGroupsCompareOptions = require('../utils/get-custom-groups-compare-options.js')
 const getOverloadSignatureGroups = require('./sort-classes/get-overload-signature-groups.js')
 const generatePredefinedGroups = require('../utils/generate-predefined-groups.js')
 const sortNodesByDependencies = require('../utils/sort-nodes-by-dependencies.js')
@@ -477,25 +477,28 @@ const sortClasses = createEslintRule.createEslintRule({
         },
         [[]],
       )
-      let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
-        sortNodesByDependencies.sortNodesByDependencies(
-          formattedNodes.flatMap(nodes2 =>
-            sortNodesByGroups.sortNodesByGroups(nodes2, options, {
-              isNodeIgnored: sortingNode =>
-                getGroupNumber.getGroupNumber(options.groups, sortingNode) ===
-                options.groups.length,
-              getGroupCompareOptions: groupNumber =>
-                getCustomGroupsCompareOptions.getCustomGroupsCompareOptions(
-                  options,
-                  groupNumber,
-                ),
-              ignoreEslintDisabledNodes,
-            }),
-          ),
+      let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes => {
+        let nodesSortedByGroups = formattedNodes.flatMap(nodes2 =>
+          sortNodesByGroups.sortNodesByGroups({
+            isNodeIgnored: sortingNode =>
+              getGroupNumber.getGroupNumber(options.groups, sortingNode) ===
+              options.groups.length,
+            getOptionsByGroupNumber:
+              getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
+                options,
+              ),
+            ignoreEslintDisabledNodes,
+            groups: options.groups,
+            nodes: nodes2,
+          }),
+        )
+        return sortNodesByDependencies.sortNodesByDependencies(
+          nodesSortedByGroups,
           {
             ignoreEslintDisabledNodes,
           },
         )
+      }
       let nodes = formattedNodes.flat()
       reportAllErrors.reportAllErrors({
         newlinesBetweenValueGetter: ({

package/dist/rules/sort-decorators.js

@@ -199,8 +199,11 @@ let sortDecorators$1 = (context, options, decorators) => {
   )
   let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
     formattedMembers.flatMap(nodes2 =>
-      sortNodesByGroups.sortNodesByGroups(nodes2, options, {
+      sortNodesByGroups.sortNodesByGroups({
+        getOptionsByGroupNumber: () => ({ options }),
         ignoreEslintDisabledNodes,
+        groups: options.groups,
+        nodes: nodes2,
       }),
     )
   let nodes = formattedMembers.flat()

package/dist/rules/sort-enums.js

@@ -98,7 +98,7 @@ const sortEnums = createEslintRule.createEslintRule({
       }
       let formattedMembers = members.reduce(
         (accumulator, member) => {
-          var _a
+          var _a, _b, _c
           let dependencies = []
           if (member.initializer) {
             dependencies = extractDependencies(
@@ -131,6 +131,13 @@ const sortEnums = createEslintRule.createEslintRule({
             numericValue: member.initializer
               ? getExpressionNumberValue(member.initializer)
               : null,
+            value:
+              ((_b = member.initializer) == null ? void 0 : _b.type) ===
+              'Literal'
+                ? (((_c = member.initializer.value) == null
+                    ? void 0
+                    : _c.toString()) ?? null)
+                : null,
             isEslintDisabled: isNodeEslintDisabled.isNodeEslintDisabled(
               member,
               eslintDisabledLines,
@@ -162,55 +169,40 @@ const sortEnums = createEslintRule.createEslintRule({
           sortingNode.numericValue !== null &&
           !Number.isNaN(sortingNode.numericValue),
       )
-      let compareOptions = {
+      let nodeValueGetter = computeNodeValueGetter({
+        isNumericEnum,
+        options,
+      })
+      let overriddenOptions = {
         ...options,
-        // 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 (
-                  ((_a = sortingNode.node.initializer) == null
-                    ? void 0
-                    : _a.type) === 'Literal'
-                ) {
-                  return (
-                    ((_b = sortingNode.node.initializer.value) == null
-                      ? void 0
-                      : _b.toString()) ?? ''
-                  )
-                }
-                return ''
-              }
-            : null,
-        /**
-         * If the enum is numeric, and we sort by value, always use the
-         * `natural` sort type, which will correctly sort them.
-         */
-        type:
-          isNumericEnum && (options.forceNumericSort || options.sortByValue)
-            ? 'natural'
-            : options.type,
+        type: computeOptionType({
+          isNumericEnum,
+          options,
+        }),
       }
-      let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
-        sortNodesByDependencies.sortNodesByDependencies(
-          formattedMembers.flatMap(sortingNodes =>
-            sortNodesByGroups.sortNodesByGroups(sortingNodes, compareOptions, {
-              getGroupCompareOptions: groupNumber =>
-                getCustomGroupsCompareOptions.getCustomGroupsCompareOptions(
-                  compareOptions,
+      let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes => {
+        let nodesSortedByGroups = formattedMembers.flatMap(sortingNodes =>
+          sortNodesByGroups.sortNodesByGroups({
+            getOptionsByGroupNumber: groupNumber => ({
+              options:
+                getCustomGroupsCompareOptions.getCustomGroupOverriddenOptions({
+                  options: overriddenOptions,
                   groupNumber,
-                ),
-              ignoreEslintDisabledNodes,
+                }),
+              nodeValueGetter,
             }),
-          ),
+            ignoreEslintDisabledNodes,
+            groups: options.groups,
+            nodes: sortingNodes,
+          }),
+        )
+        return sortNodesByDependencies.sortNodesByDependencies(
+          nodesSortedByGroups,
           {
             ignoreEslintDisabledNodes,
           },
         )
+      }
       reportAllErrors.reportAllErrors({
         availableMessageIds: {
           missedSpacingBetweenMembers: 'missedSpacingBetweenEnumsMembers',
@@ -346,4 +338,22 @@ let getBinaryExpressionNumberValue = (
       return Number.NaN
   }
 }
+let computeNodeValueGetter = ({ isNumericEnum, options }) =>
+  // Get the enum value rather than the name if needed.
+  options.sortByValue || (isNumericEnum && options.forceNumericSort)
+    ? sortingNode => {
+        if (isNumericEnum) {
+          return sortingNode.numericValue.toString()
+        }
+        return sortingNode.value ?? ''
+      }
+    : null
+let computeOptionType = ({ isNumericEnum, options }) =>
+  /**
+   * If the enum is numeric, and we sort by value, always use the
+   * `natural` sort type, which will correctly sort them.
+   */
+  isNumericEnum && (options.forceNumericSort || options.sortByValue)
+    ? 'natural'
+    : options.type
 module.exports = sortEnums

package/dist/rules/sort-exports.js

@@ -84,8 +84,10 @@ const sortExports = createEslintRule.createEslintRule({
           )
           let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
             filteredGroupKindNodes.flatMap(groupedNodes =>
-              sortNodes.sortNodes(groupedNodes, options, {
+              sortNodes.sortNodes({
                 ignoreEslintDisabledNodes,
+                nodes: groupedNodes,
+                options,
               }),
             )
           reportAllErrors.reportAllErrors({

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

@@ -98,8 +98,11 @@ let sortHeritageClauses$1 = (context, options, heritageClauses) => {
     }
   })
   let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
-    sortNodesByGroups.sortNodesByGroups(nodes, options, {
+    sortNodesByGroups.sortNodesByGroups({
+      getOptionsByGroupNumber: () => ({ options }),
       ignoreEslintDisabledNodes,
+      groups: options.groups,
+      nodes,
     })
   reportAllErrors.reportAllErrors({
     availableMessageIds: {

package/dist/rules/sort-imports.js

@@ -362,16 +362,26 @@ const sortImports = createEslintRule.createEslintRule({
         }
         for (let nodes of formattedMembers) {
           let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
-            sortNodesByGroups.sortNodesByGroups(nodes, options, {
-              getGroupCompareOptions: groupNumber => {
+            sortNodesByGroups.sortNodesByGroups({
+              getOptionsByGroupNumber: groupNumber => {
                 if (options.sortSideEffects) {
-                  return options
+                  return {
+                    options,
+                  }
+                }
+                return {
+                  options: {
+                    ...options,
+                    type: isSideEffectOnlyGroup(options.groups[groupNumber])
+                      ? 'unsorted'
+                      : options.type,
+                  },
                 }
-                let group = options.groups[groupNumber]
-                return isSideEffectOnlyGroup(group) ? null : options
               },
               isNodeIgnored: node => node.isIgnored,
               ignoreEslintDisabledNodes,
+              groups: options.groups,
+              nodes,
             })
           reportAllErrors.reportAllErrors({
             availableMessageIds: {

package/dist/rules/sort-interfaces.js

@@ -15,6 +15,7 @@ let defaultOptions = {
   ignoreCase: true,
   customGroups: {},
   locales: 'en-US',
+  sortBy: 'name',
   alphabet: '',
   order: 'asc',
   groups: [],

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

@@ -142,8 +142,11 @@ const sortJsxProps = createEslintRule.createEslintRule({
       )
       for (let nodes of formattedMembers) {
         let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
-          sortNodesByGroups.sortNodesByGroups(nodes, options, {
+          sortNodesByGroups.sortNodesByGroups({
+            getOptionsByGroupNumber: () => ({ options }),
             ignoreEslintDisabledNodes,
+            groups: options.groups,
+            nodes,
           })
         reportAllErrors.reportAllErrors({
           availableMessageIds: {

package/dist/rules/sort-maps.js

@@ -1,9 +1,9 @@
 'use strict'
 const commonJsonSchemas = require('../utils/common-json-schemas.js')
 const reportErrors = require('../utils/report-errors.js')
+const getCustomGroupsCompareOptions = require('../utils/get-custom-groups-compare-options.js')
 const validateGeneratedGroupsConfiguration = require('../utils/validate-generated-groups-configuration.js')
 const validateCustomSortConfiguration = require('../utils/validate-custom-sort-configuration.js')
-const getCustomGroupsCompareOptions = require('../utils/get-custom-groups-compare-options.js')
 const getMatchingContextOptions = require('../utils/get-matching-context-options.js')
 const getEslintDisabledLines = require('../utils/get-eslint-disabled-lines.js')
 const doesCustomGroupMatch = require('./sort-maps/does-custom-group-match.js')
@@ -137,13 +137,14 @@ const sortMaps = createEslintRule.createEslintRule({
         }
         for (let nodes of formattedMembers) {
           let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
-            sortNodesByGroups.sortNodesByGroups(nodes, options, {
-              getGroupCompareOptions: groupNumber =>
-                getCustomGroupsCompareOptions.getCustomGroupsCompareOptions(
+            sortNodesByGroups.sortNodesByGroups({
+              getOptionsByGroupNumber:
+                getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
                   options,
-                  groupNumber,
                 ),
               ignoreEslintDisabledNodes,
+              groups: options.groups,
+              nodes,
             })
           reportAllErrors.reportAllErrors({
             availableMessageIds: {

package/dist/rules/sort-modules.js

@@ -3,10 +3,10 @@ const utils = require('@typescript-eslint/utils')
 const commonJsonSchemas = require('../utils/common-json-schemas.js')
 const reportErrors = require('../utils/report-errors.js')
 const validateNewlinesAndPartitionConfiguration = require('../utils/validate-newlines-and-partition-configuration.js')
+const getCustomGroupsCompareOptions = require('../utils/get-custom-groups-compare-options.js')
 const validateGeneratedGroupsConfiguration = require('../utils/validate-generated-groups-configuration.js')
 const types = require('./sort-modules/types.js')
 const validateCustomSortConfiguration = require('../utils/validate-custom-sort-configuration.js')
-const getCustomGroupsCompareOptions = require('../utils/get-custom-groups-compare-options.js')
 const generatePredefinedGroups = require('../utils/generate-predefined-groups.js')
 const sortNodesByDependencies = require('../utils/sort-nodes-by-dependencies.js')
 const doesCustomGroupMatch = require('./sort-modules/does-custom-group-match.js')
@@ -290,25 +290,28 @@ let analyzeModule = ({
     }
     ;(_b = formattedNodes.at(-1)) == null ? void 0 : _b.push(sortingNode)
   }
-  let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
-    sortNodesByDependencies.sortNodesByDependencies(
-      formattedNodes.flatMap(nodes2 =>
-        sortNodesByGroups.sortNodesByGroups(nodes2, options, {
-          isNodeIgnored: sortingNode =>
-            getGroupNumber.getGroupNumber(options.groups, sortingNode) ===
-            options.groups.length,
-          getGroupCompareOptions: groupNumber =>
-            getCustomGroupsCompareOptions.getCustomGroupsCompareOptions(
-              options,
-              groupNumber,
-            ),
-          ignoreEslintDisabledNodes,
-        }),
-      ),
+  let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes => {
+    let nodesSortedByGroups = formattedNodes.flatMap(nodes2 =>
+      sortNodesByGroups.sortNodesByGroups({
+        isNodeIgnored: sortingNode =>
+          getGroupNumber.getGroupNumber(options.groups, sortingNode) ===
+          options.groups.length,
+        getOptionsByGroupNumber:
+          getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
+            options,
+          ),
+        ignoreEslintDisabledNodes,
+        groups: options.groups,
+        nodes: nodes2,
+      }),
+    )
+    return sortNodesByDependencies.sortNodesByDependencies(
+      nodesSortedByGroups,
       {
         ignoreEslintDisabledNodes,
       },
     )
+  }
   let nodes = formattedNodes.flat()
   reportAllErrors.reportAllErrors({
     availableMessageIds: {

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

@@ -102,8 +102,10 @@ const sortNamedExports = createEslintRule.createEslintRule({
         )
         let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
           filteredGroupKindNodes.flatMap(groupedNodes =>
-            sortNodes.sortNodes(groupedNodes, options, {
+            sortNodes.sortNodes({
               ignoreEslintDisabledNodes,
+              nodes: groupedNodes,
+              options,
             }),
           )
         reportAllErrors.reportAllErrors({

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

@@ -103,8 +103,10 @@ const sortNamedImports = createEslintRule.createEslintRule({
         )
         let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
           filteredGroupKindNodes.flatMap(groupedNodes =>
-            sortNodes.sortNodes(groupedNodes, options, {
+            sortNodes.sortNodes({
               ignoreEslintDisabledNodes,
+              nodes: groupedNodes,
+              options,
             }),
           )
         reportAllErrors.reportAllErrors({

package/dist/rules/sort-object-types/build-node-value-getter.js

@@ -0,0 +1,5 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+let buildNodeValueGetter = sortBy =>
+  sortBy === 'value' ? node => node.value ?? '' : null
+exports.buildNodeValueGetter = buildNodeValueGetter

package/dist/rules/sort-object-types/does-custom-group-match.js

@@ -32,6 +32,18 @@ let doesCustomGroupMatch = props => {
       return false
     }
   }
+  if (
+    'elementValuePattern' in props.customGroup &&
+    props.customGroup.elementValuePattern
+  ) {
+    let matchesElementValuePattern = matches.matches(
+      props.elementValue ?? '',
+      props.customGroup.elementValuePattern,
+    )
+    if (!matchesElementValuePattern) {
+      return false
+    }
+  }
   return true
 }
 exports.doesCustomGroupMatch = doesCustomGroupMatch

package/dist/rules/sort-object-types/get-custom-groups-compare-options.js

@@ -0,0 +1,44 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+const getCustomGroupsCompareOptions$1 = require('../../utils/get-custom-groups-compare-options.js')
+const buildNodeValueGetter = require('./build-node-value-getter.js')
+let getCustomGroupsCompareOptions = (options, groupNumber) => {
+  var _a
+  let baseCompareOptions =
+    getCustomGroupsCompareOptions$1.getCustomGroupsCompareOptions(
+      options,
+      groupNumber,
+    )
+  let { fallbackSort, customGroups, sortBy, groups } = options
+  let fallbackSortBy = fallbackSort.sortBy
+  if (Array.isArray(customGroups)) {
+    let group = groups[groupNumber]
+    let customGroup =
+      typeof group === 'string'
+        ? customGroups.find(currentGroup => group === currentGroup.groupName)
+        : null
+    if (customGroup) {
+      fallbackSortBy =
+        ((_a = customGroup.fallbackSort) == null ? void 0 : _a.sortBy) ??
+        fallbackSortBy
+      if ('sortBy' in customGroup && customGroup.sortBy) {
+        ;({ sortBy } = customGroup)
+      }
+    }
+  }
+  return {
+    options: {
+      ...baseCompareOptions,
+      fallbackSort: {
+        ...baseCompareOptions.fallbackSort,
+        sortBy: fallbackSortBy,
+      },
+      sortBy,
+    },
+    fallbackSortNodeValueGetter: fallbackSortBy
+      ? buildNodeValueGetter.buildNodeValueGetter(fallbackSortBy)
+      : null,
+    nodeValueGetter: buildNodeValueGetter.buildNodeValueGetter(sortBy),
+  }
+}
+exports.getCustomGroupsCompareOptions = getCustomGroupsCompareOptions

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

@@ -9,12 +9,19 @@ let allSelectors = [
   'property',
 ]
 let allModifiers = ['optional', 'required', 'multiline']
+let sortByJsonSchema = {
+  enum: ['name', 'value'],
+  type: 'string',
+}
 let singleCustomGroupJsonSchema = {
   modifiers:
     commonJsonSchemas.buildCustomGroupModifiersJsonSchema(allModifiers),
   selector: commonJsonSchemas.buildCustomGroupSelectorJsonSchema(allSelectors),
+  elementValuePattern: commonJsonSchemas.regexJsonSchema,
   elementNamePattern: commonJsonSchemas.regexJsonSchema,
+  sortBy: sortByJsonSchema,
 }
 exports.allModifiers = allModifiers
 exports.allSelectors = allSelectors
 exports.singleCustomGroupJsonSchema = singleCustomGroupJsonSchema
+exports.sortByJsonSchema = sortByJsonSchema

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

@@ -8,8 +8,8 @@ const reportErrors = require('../utils/report-errors.js')
 const validateNewlinesAndPartitionConfiguration = require('../utils/validate-newlines-and-partition-configuration.js')
 const types = require('./sort-object-types/types.js')
 const validateGeneratedGroupsConfiguration = require('../utils/validate-generated-groups-configuration.js')
+const getCustomGroupsCompareOptions = require('./sort-object-types/get-custom-groups-compare-options.js')
 const validateCustomSortConfiguration = require('../utils/validate-custom-sort-configuration.js')
-const getCustomGroupsCompareOptions = require('../utils/get-custom-groups-compare-options.js')
 const doesCustomGroupMatch = require('./sort-object-types/does-custom-group-match.js')
 const getMatchingContextOptions = require('../utils/get-matching-context-options.js')
 const generatePredefinedGroups = require('../utils/generate-predefined-groups.js')
@@ -30,7 +30,7 @@ const complete = require('../utils/complete.js')
 const matches = require('../utils/matches.js')
 let cachedGroupsByModifiersAndSelectors = /* @__PURE__ */ new Map()
 let defaultOptions = {
-  fallbackSort: { type: 'unsorted' },
+  fallbackSort: { type: 'unsorted', sortBy: 'name' },
   partitionByComment: false,
   partitionByNewLine: false,
   newlinesBetween: 'ignore',
@@ -42,6 +42,7 @@ let defaultOptions = {
   ignoreCase: true,
   customGroups: {},
   locales: 'en-US',
+  sortBy: 'name',
   alphabet: '',
   order: 'asc',
   groups: [],
@@ -49,11 +50,16 @@ let defaultOptions = {
 let jsonSchema = {
   items: {
     properties: {
-      ...commonJsonSchemas.commonJsonSchemas,
+      ...commonJsonSchemas.buildCommonJsonSchemas({
+        additionalFallbackSortProperties: {},
+      }),
       customGroups: {
         oneOf: [
           commonJsonSchemas.customGroupsJsonSchema,
           commonJsonSchemas.buildCustomGroupsArrayJsonSchema({
+            additionalFallbackSortProperties: {
+              sortBy: types.sortByJsonSchema,
+            },
             singleCustomGroupJsonSchema: types.singleCustomGroupJsonSchema,
           }),
         ],
@@ -72,6 +78,7 @@ let jsonSchema = {
       partitionByNewLine: commonJsonSchemas.partitionByNewLineJsonSchema,
       newlinesBetween: commonJsonSchemas.newlinesBetweenJsonSchema,
       ignorePattern: commonJsonSchemas.regexJsonSchema,
+      sortBy: types.sortByJsonSchema,
       groups: commonJsonSchemas.groupsJsonSchema,
     },
     additionalProperties: false,
@@ -223,10 +230,18 @@ let sortObjectTypeElements = ({
         defineGroup(predefinedGroup)
       }
       let name = getNodeName({ typeElement, sourceCode })
+      let value = null
+      if (
+        typeElement.type === 'TSPropertySignature' &&
+        typeElement.typeAnnotation
+      ) {
+        value = sourceCode.getText(typeElement.typeAnnotation.typeAnnotation)
+      }
       if (Array.isArray(options.customGroups)) {
         for (let customGroup of options.customGroups) {
           if (
             doesCustomGroupMatch.doesCustomGroupMatch({
+              elementValue: value,
               elementName: name,
               customGroup,
               selectors,
@@ -256,6 +271,7 @@ let sortObjectTypeElements = ({
         addSafetySemicolonWhenInline: true,
         group: getGroup(),
         node: typeElement,
+        value,
         name,
       }
       if (
@@ -291,13 +307,34 @@ let sortObjectTypeElements = ({
     )
     let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
       filteredGroupKindNodes.flatMap(groupedNodes =>
-        sortNodesByGroups.sortNodesByGroups(groupedNodes, options, {
-          getGroupCompareOptions: groupNumber =>
-            getCustomGroupsCompareOptions.getCustomGroupsCompareOptions(
+        sortNodesByGroups.sortNodesByGroups({
+          getOptionsByGroupNumber: groupNumber => {
+            let {
+              fallbackSortNodeValueGetter,
+              options: overriddenOptions,
+              nodeValueGetter,
+            } = getCustomGroupsCompareOptions.getCustomGroupsCompareOptions(
               options,
               groupNumber,
-            ),
+            )
+            return {
+              options: {
+                ...options,
+                ...overriddenOptions,
+              },
+              fallbackSortNodeValueGetter,
+              nodeValueGetter,
+            }
+          },
+          isNodeIgnoredForGroup: (node, groupOptions) => {
+            if (groupOptions.sortBy === 'value') {
+              return !node.value
+            }
+            return false
+          },
           ignoreEslintDisabledNodes,
+          groups: options.groups,
+          nodes: groupedNodes,
         }),
       )
     reportAllErrors.reportAllErrors({

package/dist/rules/sort-objects.js

@@ -3,17 +3,17 @@ const types$1 = require('@typescript-eslint/types')
 const commonJsonSchemas = require('../utils/common-json-schemas.js')
 const reportErrors = require('../utils/report-errors.js')
 const validateNewlinesAndPartitionConfiguration = require('../utils/validate-newlines-and-partition-configuration.js')
+const getCustomGroupsCompareOptions = require('../utils/get-custom-groups-compare-options.js')
 const validateGeneratedGroupsConfiguration = require('../utils/validate-generated-groups-configuration.js')
+const types = require('./sort-objects/types.js')
 const validateCustomSortConfiguration = require('../utils/validate-custom-sort-configuration.js')
 const getFirstNodeParentWithType = require('./sort-objects/get-first-node-parent-with-type.js')
-const getCustomGroupsCompareOptions = require('../utils/get-custom-groups-compare-options.js')
 const getMatchingContextOptions = require('../utils/get-matching-context-options.js')
 const generatePredefinedGroups = require('../utils/generate-predefined-groups.js')
 const sortNodesByDependencies = require('../utils/sort-nodes-by-dependencies.js')
 const doesCustomGroupMatch = require('./sort-objects/does-custom-group-match.js')
 const getEslintDisabledLines = require('../utils/get-eslint-disabled-lines.js')
 const isNodeEslintDisabled = require('../utils/is-node-eslint-disabled.js')
-const types = require('./sort-objects/types.js')
 const sortNodesByGroups = require('../utils/sort-nodes-by-groups.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const reportAllErrors = require('../utils/report-all-errors.js')
@@ -325,28 +325,38 @@ const sortObjects = createEslintRule.createEslintRule({
           [[]],
         )
       let formattedMembers = formatProperties(nodeObject.properties)
+      let sortingOptions = options
       let nodesSortingFunction =
         isDestructuredObject &&
         typeof options.destructuredObjects === 'object' &&
         !options.destructuredObjects.groups
-          ? sortNodes.sortNodes
-          : sortNodesByGroups.sortNodesByGroups
-      let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
-        sortNodesByDependencies.sortNodesByDependencies(
-          formattedMembers.flatMap(nodes2 =>
-            nodesSortingFunction(nodes2, options, {
-              getGroupCompareOptions: groupNumber =>
-                getCustomGroupsCompareOptions.getCustomGroupsCompareOptions(
-                  options,
-                  groupNumber,
-                ),
-              ignoreEslintDisabledNodes,
-            }),
-          ),
+          ? 'sortNodes'
+          : 'sortNodesByGroups'
+      let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes => {
+        let nodesSortedByGroups = formattedMembers.flatMap(nodes2 =>
+          nodesSortingFunction === 'sortNodes'
+            ? sortNodes.sortNodes({
+                ignoreEslintDisabledNodes,
+                options: sortingOptions,
+                nodes: nodes2,
+              })
+            : sortNodesByGroups.sortNodesByGroups({
+                getOptionsByGroupNumber:
+                  getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
+                    options,
+                  ),
+                ignoreEslintDisabledNodes,
+                groups: options.groups,
+                nodes: nodes2,
+              }),
+        )
+        return sortNodesByDependencies.sortNodesByDependencies(
+          nodesSortedByGroups,
           {
             ignoreEslintDisabledNodes,
           },
         )
+      }
       let nodes = formattedMembers.flat()
       reportAllErrors.reportAllErrors({
         availableMessageIds: {

package/dist/rules/sort-switch-case.js

@@ -65,10 +65,11 @@ const sortSwitchCase = createEslintRule.createEslintRule({
       )
       let hasUnsortedNodes = false
       for (let caseNodesSortingNodeGroup of caseNameSortingNodeGroups) {
-        let sortedCaseNameSortingNodes = sortNodes.sortNodes(
-          caseNodesSortingNodeGroup,
+        let sortedCaseNameSortingNodes = sortNodes.sortNodes({
+          nodes: caseNodesSortingNodeGroup,
+          ignoreEslintDisabledNodes: false,
           options,
-        )
+        })
         hasUnsortedNodes ||
           (hasUnsortedNodes = sortedCaseNameSortingNodes.some(
             (node, index) => node !== caseNodesSortingNodeGroup[index],
@@ -188,7 +189,11 @@ const sortSwitchCase = createEslintRule.createEslintRule({
           if (b.some(node => node.isDefaultClause)) {
             return -1
           }
-          return compare.compare(a.at(0), b.at(0), options)
+          return compare.compare({
+            a: a.at(0),
+            b: b.at(0),
+            options,
+          })
         })
         .flat()
       let sortingNodeGroupsForBlockSortFlat =

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

@@ -209,8 +209,11 @@ let sortUnionOrIntersectionTypes = ({
   )
   for (let nodes of formattedMembers) {
     let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
-      sortNodesByGroups.sortNodesByGroups(nodes, options, {
+      sortNodesByGroups.sortNodesByGroups({
+        getOptionsByGroupNumber: () => ({ options }),
         ignoreEslintDisabledNodes,
+        groups: options.groups,
+        nodes,
       })
     reportAllErrors.reportAllErrors({
       sortNodesExcludingEslintDisabled,

package/dist/rules/sort-variable-declarations.js

@@ -161,8 +161,10 @@ const sortVariableDeclarations = createEslintRule.createEslintRule({
       let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
         sortNodesByDependencies.sortNodesByDependencies(
           formattedMembers.flatMap(nodes2 =>
-            sortNodes.sortNodes(nodes2, options, {
+            sortNodes.sortNodes({
               ignoreEslintDisabledNodes,
+              options,
+              nodes: nodes2,
             }),
           ),
           {

package/dist/utils/common-json-schemas.js

@@ -39,23 +39,25 @@ let specialCharactersJsonSchema = {
   enum: ['remove', 'trim', 'keep'],
   type: 'string',
 }
-let fallbackSortJsonSchema = {
+let buildFallbackSortJsonSchema = ({ additionalProperties } = {}) => ({
   properties: {
     order: orderJsonSchema,
     type: typeJsonSchema,
+    ...additionalProperties,
   },
   description: 'Fallback sort order.',
   type: 'object',
-}
-let commonJsonSchemas = {
+})
+let buildCommonJsonSchemas = ({ additionalFallbackSortProperties } = {}) => ({
+  fallbackSort: buildFallbackSortJsonSchema(additionalFallbackSortProperties),
   specialCharacters: specialCharactersJsonSchema,
-  fallbackSort: fallbackSortJsonSchema,
   ignoreCase: ignoreCaseJsonSchema,
   alphabet: alphabetJsonSchema,
   locales: localesJsonSchema,
   order: orderJsonSchema,
   type: typeJsonSchema,
-}
+})
+let commonJsonSchemas = buildCommonJsonSchemas()
 let newlinesBetweenJsonSchema = {
   description: 'Specifies how new lines should be handled between groups.',
   enum: ['ignore', 'always', 'never'],
@@ -170,40 +172,36 @@ let buildUseConfigurationIfJsonSchema = ({ additionalProperties } = {}) => ({
   additionalProperties: false,
   type: 'object',
 })
-let customGroupSortJsonSchema = {
-  type: {
-    enum: ['alphabetical', 'line-length', 'natural', 'unsorted'],
-    description: 'Custom group sort type.',
-    type: 'string',
-  },
-  order: {
-    description: 'Custom group sort order.',
-    enum: ['desc', 'asc'],
-    type: 'string',
-  },
-}
-let customGroupNameJsonSchema = {
-  groupName: {
-    description: 'Custom group name.',
-    type: 'string',
-  },
-}
-let customGroupNewlinesInsideJsonSchema = {
+let buildCommonCustomGroupJsonSchemas = ({
+  additionalFallbackSortProperties,
+} = {}) => ({
   newlinesInside: {
     description:
       'Specifies how new lines should be handled between members of the custom group.',
     enum: ['always', 'never'],
     type: 'string',
   },
-}
-let buildCustomGroupsArrayJsonSchema = ({ singleCustomGroupJsonSchema }) => ({
+  fallbackSort: buildFallbackSortJsonSchema({
+    additionalProperties: additionalFallbackSortProperties,
+  }),
+  groupName: {
+    description: 'Custom group name.',
+    type: 'string',
+  },
+  order: orderJsonSchema,
+  type: typeJsonSchema,
+})
+let buildCustomGroupsArrayJsonSchema = ({
+  additionalFallbackSortProperties,
+  singleCustomGroupJsonSchema,
+}) => ({
   items: {
     oneOf: [
       {
         properties: {
-          ...customGroupNameJsonSchema,
-          ...customGroupSortJsonSchema,
-          ...customGroupNewlinesInsideJsonSchema,
+          ...buildCommonCustomGroupJsonSchemas({
+            additionalFallbackSortProperties,
+          }),
           anyOf: {
             items: {
               properties: {
@@ -222,9 +220,9 @@ let buildCustomGroupsArrayJsonSchema = ({ singleCustomGroupJsonSchema }) => ({
       },
       {
         properties: {
-          ...customGroupNameJsonSchema,
-          ...customGroupSortJsonSchema,
-          ...customGroupNewlinesInsideJsonSchema,
+          ...buildCommonCustomGroupJsonSchemas({
+            additionalFallbackSortProperties,
+          }),
           ...singleCustomGroupJsonSchema,
         },
         description: 'Custom group.',
@@ -249,6 +247,7 @@ let buildCustomGroupSelectorJsonSchema = selectors => ({
   enum: selectors,
   type: 'string',
 })
+exports.buildCommonJsonSchemas = buildCommonJsonSchemas
 exports.buildCustomGroupModifiersJsonSchema =
   buildCustomGroupModifiersJsonSchema
 exports.buildCustomGroupSelectorJsonSchema = buildCustomGroupSelectorJsonSchema

package/dist/utils/compare.js

@@ -3,9 +3,37 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 const naturalOrderby = require('natural-orderby')
 const convertBooleanToSign = require('./convert-boolean-to-sign.js')
 let alphabetCache = /* @__PURE__ */ new Map()
-let compare = (a, b, options) => {
+let compare = ({
+  fallbackSortNodeValueGetter,
+  nodeValueGetter,
+  options,
+  a,
+  b,
+}) => {
+  let finalNodeValueGetter = nodeValueGetter ?? (node => node.name)
+  let compareValue = computeCompareValue({
+    nodeValueGetter: finalNodeValueGetter,
+    options,
+    a,
+    b,
+  })
+  if (compareValue) {
+    return compareValue
+  }
+  let { fallbackSort, order } = options
+  return computeCompareValue({
+    options: {
+      ...options,
+      order: fallbackSort.order ?? order,
+      type: fallbackSort.type,
+    },
+    nodeValueGetter: fallbackSortNodeValueGetter ?? finalNodeValueGetter,
+    a,
+    b,
+  })
+}
+let computeCompareValue = ({ nodeValueGetter, options, a, b }) => {
   let sortingFunction
-  let nodeValueGetter = options.nodeValueGetter ?? (node => node.name)
   switch (options.type) {
     case 'alphabetical':
       sortingFunction = getAlphabeticalSortingFunction(options, nodeValueGetter)
@@ -22,19 +50,10 @@ let compare = (a, b, options) => {
       sortingFunction = getCustomSortingFunction(options, nodeValueGetter)
       break
   }
-  let compareValue =
+  return (
     convertBooleanToSign.convertBooleanToSign(options.order === 'asc') *
     sortingFunction(a, b)
-  if (compareValue) {
-    return compareValue
-  }
-  let { fallbackSort, order } = options
-  return compare(a, b, {
-    ...options,
-    order: fallbackSort.order ?? order,
-    type: fallbackSort.type,
-    fallbackSort,
-  })
+  )
 }
 let getAlphabeticalSortingFunction = (
   { specialCharacters, ignoreCase, locales },

package/dist/utils/get-custom-groups-compare-options.js

@@ -1,20 +1,47 @@
 'use strict'
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 let getCustomGroupsCompareOptions = (options, groupNumber) => {
-  if (!Array.isArray(options.customGroups)) {
-    return options
+  var _a, _b
+  let { customGroups, fallbackSort, groups, order, type } = options
+  if (Array.isArray(customGroups)) {
+    let group = groups[groupNumber]
+    let customGroup =
+      typeof group === 'string'
+        ? customGroups.find(currentGroup => group === currentGroup.groupName)
+        : null
+    if (customGroup) {
+      fallbackSort = {
+        type:
+          ((_a = customGroup.fallbackSort) == null ? void 0 : _a.type) ??
+          fallbackSort.type,
+      }
+      let fallbackOrder =
+        ((_b = customGroup.fallbackSort) == null ? void 0 : _b.order) ??
+        fallbackSort.order
+      if (fallbackOrder) {
+        fallbackSort.order = fallbackOrder
+      }
+      order = customGroup.order ?? order
+      type = customGroup.type ?? type
+    }
   }
-  let group = options.groups[groupNumber]
-  let customGroup =
-    typeof group === 'string'
-      ? options.customGroups.find(
-          currentGroup => group === currentGroup.groupName,
-        )
-      : null
   return {
-    ...options,
-    order: (customGroup == null ? void 0 : customGroup.order) ?? options.order,
-    type: (customGroup == null ? void 0 : customGroup.type) ?? options.type,
+    fallbackSort,
+    order,
+    type,
   }
 }
+let buildGetCustomGroupOverriddenOptionsFunction = options => groupNumber => ({
+  options: getCustomGroupOverriddenOptions({
+    groupNumber,
+    options,
+  }),
+})
+let getCustomGroupOverriddenOptions = ({ groupNumber, options }) => ({
+  ...options,
+  ...getCustomGroupsCompareOptions(options, groupNumber),
+})
+exports.buildGetCustomGroupOverriddenOptionsFunction =
+  buildGetCustomGroupOverriddenOptionsFunction
+exports.getCustomGroupOverriddenOptions = getCustomGroupOverriddenOptions
 exports.getCustomGroupsCompareOptions = getCustomGroupsCompareOptions

package/dist/utils/get-settings.js

@@ -10,6 +10,7 @@ let getSettings = (settings = {}) => {
       'partitionByNewLine',
       'specialCharacters',
       'ignorePattern',
+      'fallbackSort',
       'ignoreCase',
       'alphabet',
       'locales',

package/dist/utils/sort-nodes-by-groups.js

@@ -2,24 +2,25 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 const getGroupNumber = require('./get-group-number.js')
 const sortNodes = require('./sort-nodes.js')
-let sortNodesByGroups = (nodes, options, extraOptions) => {
-  var _a
+let sortNodesByGroups = ({
+  ignoreEslintDisabledNodes,
+  getOptionsByGroupNumber,
+  isNodeIgnoredForGroup,
+  isNodeIgnored,
+  groups,
+  nodes,
+}) => {
   let nodesByNonIgnoredGroupNumber = {}
   let ignoredNodeIndices = []
   for (let [index, sortingNode] of nodes.entries()) {
     if (
-      (sortingNode.isEslintDisabled &&
-        (extraOptions == null
-          ? void 0
-          : extraOptions.ignoreEslintDisabledNodes)) ||
-      ((_a = extraOptions == null ? void 0 : extraOptions.isNodeIgnored) == null
-        ? void 0
-        : _a.call(extraOptions, sortingNode))
+      (sortingNode.isEslintDisabled && ignoreEslintDisabledNodes) ||
+      (isNodeIgnored == null ? void 0 : isNodeIgnored(sortingNode))
     ) {
       ignoredNodeIndices.push(index)
       continue
     }
-    let groupNumber = getGroupNumber.getGroupNumber(options.groups, sortingNode)
+    let groupNumber = getGroupNumber.getGroupNumber(groups, sortingNode)
     nodesByNonIgnoredGroupNumber[groupNumber] ??
       (nodesByNonIgnoredGroupNumber[groupNumber] = [])
     nodesByNonIgnoredGroupNumber[groupNumber].push(sortingNode)
@@ -28,17 +29,26 @@ let sortNodesByGroups = (nodes, options, extraOptions) => {
   for (let groupNumber of Object.keys(nodesByNonIgnoredGroupNumber).sort(
     (a, b) => Number(a) - Number(b),
   )) {
-    let compareOptions = (
-      extraOptions == null ? void 0 : extraOptions.getGroupCompareOptions
-    )
-      ? extraOptions.getGroupCompareOptions(Number(groupNumber))
-      : options
+    let { fallbackSortNodeValueGetter, nodeValueGetter, options } =
+      getOptionsByGroupNumber(Number(groupNumber))
     let nodesToPush = nodesByNonIgnoredGroupNumber[Number(groupNumber)]
-    if (!compareOptions) {
-      sortedNodes.push(...nodesToPush)
-      continue
-    }
-    sortedNodes.push(...sortNodes.sortNodes(nodesToPush, compareOptions))
+    let groupIgnoredNodes = new Set(
+      nodesToPush.filter(node =>
+        isNodeIgnoredForGroup == null
+          ? void 0
+          : isNodeIgnoredForGroup(node, options),
+      ),
+    )
+    sortedNodes.push(
+      ...sortNodes.sortNodes({
+        isNodeIgnored: node => groupIgnoredNodes.has(node),
+        ignoreEslintDisabledNodes: false,
+        fallbackSortNodeValueGetter,
+        nodes: nodesToPush,
+        nodeValueGetter,
+        options,
+      }),
+    )
   }
   for (let ignoredIndex of ignoredNodeIndices) {
     sortedNodes.splice(ignoredIndex, 0, nodes[ignoredIndex])

package/dist/utils/sort-nodes.js

@@ -1,13 +1,20 @@
 'use strict'
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 const compare = require('./compare.js')
-let sortNodes = (nodes, options, extraOptions) => {
+let sortNodes = ({
+  fallbackSortNodeValueGetter,
+  ignoreEslintDisabledNodes,
+  nodeValueGetter,
+  isNodeIgnored,
+  options,
+  nodes,
+}) => {
   let nonIgnoredNodes = []
   let ignoredNodeIndices = []
   for (let [index, sortingNode] of nodes.entries()) {
     if (
-      sortingNode.isEslintDisabled &&
-      (extraOptions == null ? void 0 : extraOptions.ignoreEslintDisabledNodes)
+      (sortingNode.isEslintDisabled && ignoreEslintDisabledNodes) ||
+      (isNodeIgnored == null ? void 0 : isNodeIgnored(sortingNode))
     ) {
       ignoredNodeIndices.push(index)
     } else {
@@ -15,7 +22,13 @@ let sortNodes = (nodes, options, extraOptions) => {
     }
   }
   let sortedNodes = [...nonIgnoredNodes].sort((a, b) =>
-    compare.compare(a, b, options),
+    compare.compare({
+      fallbackSortNodeValueGetter,
+      nodeValueGetter,
+      options,
+      a,
+      b,
+    }),
   )
   for (let ignoredIndex of ignoredNodeIndices) {
     sortedNodes.splice(ignoredIndex, 0, nodes[ignoredIndex])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-perfectionist",
-  "version": "4.9.0",
+  "version": "4.10.0",
   "description": "ESLint plugin for sorting various data such as objects, imports, types, enums, JSX props, etc.",
   "keywords": [
     "eslint",
@@ -27,12 +27,12 @@
     "./dist"
   ],
   "dependencies": {
-    "@typescript-eslint/types": "^8.24.0",
-    "@typescript-eslint/utils": "^8.24.0",
+    "@typescript-eslint/types": "^8.26.0",
+    "@typescript-eslint/utils": "^8.26.0",
     "natural-orderby": "^5.0.0"
   },
   "peerDependencies": {
-    "eslint": ">=8.0.0"
+    "eslint": ">=8.45.0"
   },
   "engines": {
     "node": "^18.0.0 || >=20.0.0"

package/readme.md

@@ -73,7 +73,7 @@ See [docs](https://perfectionist.dev).
 
 ## Installation
 
-You'll first need to install [ESLint](https://eslint.org):
+You'll first need to install [ESLint](https://eslint.org) v8.45.0 or greater:
 
 ```sh
 npm install --save-dev eslint