eslint-plugin-perfectionist 4.14.0 → 4.15.0

package/dist/package.json.js

@@ -1,6 +1,6 @@
 'use strict'
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 const name = 'eslint-plugin-perfectionist'
-const version = '4.14.0'
+const version = '4.15.0'
 exports.name = name
 exports.version = version

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

@@ -199,7 +199,10 @@ let sortArray = ({ availableMessageIds, elements, context }) => {
       ) {
         accumulator.push([])
       }
-      accumulator.at(-1).push(sortingNode)
+      accumulator.at(-1).push({
+        ...sortingNode,
+        partitionId: accumulator.length,
+      })
       return accumulator
     },
     [[]],
@@ -222,7 +225,7 @@ let sortArray = ({ availableMessageIds, elements, context }) => {
     let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
       filteredGroupKindNodes.flatMap(groupedNodes =>
         sortNodesByGroups.sortNodesByGroups({
-          getOptionsByGroupNumber:
+          getOptionsByGroupIndex:
             getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
               options,
             ),

package/dist/rules/sort-classes.js

@@ -465,7 +465,10 @@ const sortClasses = createEslintRule.createEslintRule({
           ) {
             accumulator.push([])
           }
-          accumulator.at(-1).push(sortingNode)
+          accumulator.at(-1).push({
+            ...sortingNode,
+            partitionId: accumulator.length,
+          })
           return accumulator
         },
         [[]],
@@ -476,7 +479,7 @@ const sortClasses = createEslintRule.createEslintRule({
             isNodeIgnored: sortingNode =>
               getGroupIndex.getGroupIndex(options.groups, sortingNode) ===
               options.groups.length,
-            getOptionsByGroupNumber:
+            getOptionsByGroupIndex:
               getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
                 options,
               ),
@@ -503,7 +506,7 @@ const sortClasses = createEslintRule.createEslintRule({
             left.overloadSignaturesGroupId !== null &&
             left.overloadSignaturesGroupId === right.overloadSignaturesGroupId
           ) {
-            return 'never'
+            return 0
           }
           return computedNewlinesBetween
         },

package/dist/rules/sort-decorators.js

@@ -194,7 +194,10 @@ let sortDecorators$1 = (context, options, decorators) => {
       ) {
         accumulator.push([])
       }
-      accumulator.at(-1).push(sortingNode)
+      accumulator.at(-1).push({
+        ...sortingNode,
+        partitionId: accumulator.length,
+      })
       return accumulator
     },
     [[]],
@@ -202,7 +205,7 @@ let sortDecorators$1 = (context, options, decorators) => {
   let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
     formattedMembers.flatMap(nodes2 =>
       sortNodesByGroups.sortNodesByGroups({
-        getOptionsByGroupNumber: () => ({ options }),
+        getOptionsByGroupIndex: () => ({ options }),
         ignoreEslintDisabledNodes,
         groups: options.groups,
         nodes: nodes2,

package/dist/rules/sort-enums.js

@@ -155,7 +155,10 @@ const sortEnums = createEslintRule.createEslintRule({
           ) {
             accumulator.push([])
           }
-          accumulator.at(-1).push(sortingNode)
+          accumulator.at(-1).push({
+            ...sortingNode,
+            partitionId: accumulator.length,
+          })
           return accumulator
         },
         [[]],
@@ -180,11 +183,11 @@ const sortEnums = createEslintRule.createEslintRule({
       let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes => {
         let nodesSortedByGroups = formattedMembers.flatMap(sortingNodes =>
           sortNodesByGroups.sortNodesByGroups({
-            getOptionsByGroupNumber: groupNumber => ({
+            getOptionsByGroupIndex: groupIndex => ({
               options:
                 getCustomGroupsCompareOptions.getCustomGroupOverriddenOptions({
                   options: overriddenOptions,
-                  groupNumber,
+                  groupIndex,
                 }),
               nodeValueGetter,
             }),

package/dist/rules/sort-exports.js

@@ -95,10 +95,11 @@ const sortExports = createEslintRule.createEslintRule({
         name,
         node,
       }
-      let lastNode = (_a = formattedMembers.at(-1)) == null ? void 0 : _a.at(-1)
+      let lastSortingNode =
+        (_a = formattedMembers.at(-1)) == null ? void 0 : _a.at(-1)
       if (
         shouldPartition.shouldPartition({
-          lastSortingNode: lastNode,
+          lastSortingNode,
           sortingNode,
           sourceCode,
           options,
@@ -106,7 +107,10 @@ const sortExports = createEslintRule.createEslintRule({
       ) {
         formattedMembers.push([])
       }
-      formattedMembers.at(-1).push(sortingNode)
+      formattedMembers.at(-1).push({
+        ...sortingNode,
+        partitionId: formattedMembers.length,
+      })
     }
     return {
       'Program:exit': () => {
@@ -128,7 +132,7 @@ const sortExports = createEslintRule.createEslintRule({
           let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
             filteredGroupKindNodes.flatMap(groupedNodes =>
               sortNodesByGroups.sortNodesByGroups({
-                getOptionsByGroupNumber:
+                getOptionsByGroupIndex:
                   getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
                     options,
                   ),

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

@@ -95,13 +95,14 @@ let sortHeritageClauses$1 = (context, options, heritageClauses) => {
       ),
       size: rangeToDiff.rangeToDiff(heritageClause, sourceCode),
       node: heritageClause,
+      partitionId: 0,
       group,
       name,
     }
   })
   let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
     sortNodesByGroups.sortNodesByGroups({
-      getOptionsByGroupNumber: () => ({ options }),
+      getOptionsByGroupIndex: () => ({ options }),
       ignoreEslintDisabledNodes,
       groups: options.groups,
       nodes,

package/dist/rules/sort-imports.js

@@ -41,11 +41,11 @@ let defaultOptions = {
   fallbackSort: { type: 'unsorted' },
   partitionByComment: false,
   partitionByNewLine: false,
-  newlinesBetween: 'always',
   specialCharacters: 'keep',
   sortSideEffects: false,
   type: 'alphabetical',
   environment: 'node',
+  newlinesBetween: 1,
   customGroups: [],
   ignoreCase: true,
   locales: 'en-US',
@@ -96,7 +96,7 @@ const sortImports = createEslintRule.createEslintRule({
       ruleName: id,
       sourceCode,
     })
-    let sortingNodes = []
+    let sortingNodesWithoutPartitionId = []
     let flatGroups = new Set(options.groups.flat())
     let shouldRegroupSideEffectNodes = flatGroups.has('side-effect')
     let shouldRegroupSideEffectStyleNodes = flatGroups.has('side-effect-style')
@@ -196,7 +196,16 @@ const sortImports = createEslintRule.createEslintRule({
             options,
             name,
           }) ?? 'unknown')
-      sortingNodes.push({
+      let hasMultipleImportDeclarations = isSortable.isSortable(node.specifiers)
+      let size = rangeToDiff.rangeToDiff(node, sourceCode)
+      if (
+        hasMultipleImportDeclarations &&
+        options.maxLineLength &&
+        size > options.maxLineLength
+      ) {
+        size = name.length + 10
+      }
+      sortingNodesWithoutPartitionId.push({
         isIgnored:
           !options.sortSideEffects &&
           isSideEffect &&
@@ -208,30 +217,28 @@ const sortImports = createEslintRule.createEslintRule({
         ),
         dependencyNames: computeDependencyNames({ sourceCode, node }),
         dependencies: computeDependencies(node),
-        size: rangeToDiff.rangeToDiff(node, sourceCode),
         addSafetySemicolonWhenInline: true,
         group,
+        size,
         name,
         node,
-        ...(options.type === 'line-length' &&
-          options.maxLineLength && {
-            hasMultipleImportDeclarations: isSortable.isSortable(
-              node.specifiers,
-            ),
-          }),
       })
     }
     return {
       'Program:exit': () => {
         let contentSeparatedSortingNodeGroups = [[[]]]
-        for (let sortingNode of sortingNodes) {
+        for (let sortingNodeWithoutPartitionId of sortingNodesWithoutPartitionId) {
           let lastGroupWithNoContentBetween =
             contentSeparatedSortingNodeGroups.at(-1)
           let lastGroup = lastGroupWithNoContentBetween.at(-1)
           let lastSortingNode = lastGroup.at(-1)
           if (
             lastSortingNode &&
-            hasContentBetweenNodes(sourceCode, lastSortingNode, sortingNode)
+            hasContentBetweenNodes(
+              sourceCode,
+              lastSortingNode,
+              sortingNodeWithoutPartitionId,
+            )
           ) {
             lastGroup = []
             lastGroupWithNoContentBetween = [lastGroup]
@@ -240,8 +247,8 @@ const sortImports = createEslintRule.createEslintRule({
             )
           } else if (
             shouldPartition.shouldPartition({
+              sortingNode: sortingNodeWithoutPartitionId,
               lastSortingNode,
-              sortingNode,
               sourceCode,
               options,
             })
@@ -249,13 +256,16 @@ const sortImports = createEslintRule.createEslintRule({
             lastGroup = []
             lastGroupWithNoContentBetween.push(lastGroup)
           }
-          lastGroup.push(sortingNode)
+          lastGroup.push({
+            ...sortingNodeWithoutPartitionId,
+            partitionId: lastGroupWithNoContentBetween.length,
+          })
         }
         for (let sortingNodeGroups of contentSeparatedSortingNodeGroups) {
           let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes => {
             let nodesSortedByGroups = sortingNodeGroups.flatMap(nodes2 =>
               sortNodesByGroups.sortNodesByGroups({
-                getOptionsByGroupNumber: groupNumber => {
+                getOptionsByGroupIndex: groupIndex => {
                   let customGroupOverriddenOptions =
                     getCustomGroupsCompareOptions.getCustomGroupOverriddenOptions(
                       {
@@ -265,7 +275,7 @@ const sortImports = createEslintRule.createEslintRule({
                             ? options.customGroups
                             : [],
                         },
-                        groupNumber,
+                        groupIndex,
                       },
                     )
                   if (options.sortSideEffects) {
@@ -284,9 +294,9 @@ const sortImports = createEslintRule.createEslintRule({
                     options: {
                       ...overriddenOptions,
                       type:
-                        overriddenOptions.groups[groupNumber] &&
+                        overriddenOptions.groups[groupIndex] &&
                         isSideEffectOnlyGroup.isSideEffectOnlyGroup(
-                          overriddenOptions.groups[groupNumber],
+                          overriddenOptions.groups[groupIndex],
                         )
                           ? 'unsorted'
                           : overriddenOptions.type,

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

@@ -166,7 +166,10 @@ const sortJsxProps = createEslintRule.createEslintRule({
           ) {
             accumulator.push([])
           }
-          accumulator.at(-1).push(sortingNode)
+          accumulator.at(-1).push({
+            ...sortingNode,
+            partitionId: accumulator.length,
+          })
           return accumulator
         },
         [[]],
@@ -174,7 +177,7 @@ const sortJsxProps = createEslintRule.createEslintRule({
       for (let nodes of formattedMembers) {
         let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
           sortNodesByGroups.sortNodesByGroups({
-            getOptionsByGroupNumber:
+            getOptionsByGroupIndex:
               getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
                 options,
               ),

package/dist/rules/sort-maps.js

@@ -129,12 +129,15 @@ const sortMaps = createEslintRule.createEslintRule({
           ) {
             formattedMembers.push([])
           }
-          formattedMembers.at(-1).push(sortingNode)
+          formattedMembers.at(-1).push({
+            ...sortingNode,
+            partitionId: formattedMembers.length,
+          })
         }
         for (let nodes of formattedMembers) {
           let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
             sortNodesByGroups.sortNodesByGroups({
-              getOptionsByGroupNumber:
+              getOptionsByGroupIndex:
                 getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
                   options,
                 ),

package/dist/rules/sort-modules.js

@@ -278,7 +278,12 @@ let analyzeModule = ({
     ) {
       formattedNodes.push([])
     }
-    ;(_b = formattedNodes.at(-1)) == null ? void 0 : _b.push(sortingNode)
+    ;(_b = formattedNodes.at(-1)) == null
+      ? void 0
+      : _b.push({
+          ...sortingNode,
+          partitionId: formattedNodes.length,
+        })
   }
   let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes => {
     let nodesSortedByGroups = formattedNodes.flatMap(nodes2 =>
@@ -286,7 +291,7 @@ let analyzeModule = ({
         isNodeIgnored: sortingNode =>
           getGroupIndex.getGroupIndex(options.groups, sortingNode) ===
           options.groups.length,
-        getOptionsByGroupNumber:
+        getOptionsByGroupIndex:
           getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
             options,
           ),

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

@@ -128,7 +128,10 @@ const sortNamedExports = createEslintRule.createEslintRule({
         ) {
           formattedMembers.push([])
         }
-        formattedMembers.at(-1).push(sortingNode)
+        formattedMembers.at(-1).push({
+          ...sortingNode,
+          partitionId: formattedMembers.length,
+        })
       }
       let groupKindOrder
       if (options.groupKind === 'values-first') {
@@ -148,7 +151,7 @@ const sortNamedExports = createEslintRule.createEslintRule({
         let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
           filteredGroupKindNodes.flatMap(groupedNodes =>
             sortNodesByGroups.sortNodesByGroups({
-              getOptionsByGroupNumber:
+              getOptionsByGroupIndex:
                 getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
                   options,
                 ),

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

@@ -132,7 +132,10 @@ const sortNamedImports = createEslintRule.createEslintRule({
         ) {
           formattedMembers.push([])
         }
-        formattedMembers.at(-1).push(sortingNode)
+        formattedMembers.at(-1).push({
+          ...sortingNode,
+          partitionId: formattedMembers.length,
+        })
       }
       let groupKindOrder
       if (options.groupKind === 'values-first') {
@@ -152,7 +155,7 @@ const sortNamedImports = createEslintRule.createEslintRule({
         let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
           filteredGroupKindNodes.flatMap(groupedNodes =>
             sortNodesByGroups.sortNodesByGroups({
-              getOptionsByGroupNumber:
+              getOptionsByGroupIndex:
                 getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
                   options,
                 ),

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

@@ -2,17 +2,17 @@
 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) => {
+let getCustomGroupsCompareOptions = (options, groupIndex) => {
   var _a
   let baseCompareOptions =
     getCustomGroupsCompareOptions$1.getCustomGroupsCompareOptions(
       options,
-      groupNumber,
+      groupIndex,
     )
   let { fallbackSort, customGroups, sortBy, groups } = options
   let fallbackSortBy = fallbackSort.sortBy
   if (Array.isArray(customGroups)) {
-    let group = groups[groupNumber]
+    let group = groups[groupIndex]
     let customGroup =
       typeof group === 'string'
         ? customGroups.find(currentGroup => group === currentGroup.groupName)

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

@@ -256,6 +256,7 @@ let sortObjectTypeElements = ({
           : 'required',
         size: rangeToDiff.rangeToDiff(typeElement, sourceCode),
         addSafetySemicolonWhenInline: true,
+        partitionId: accumulator.length,
         node: typeElement,
         group,
         value,
@@ -295,14 +296,14 @@ let sortObjectTypeElements = ({
     let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
       filteredGroupKindNodes.flatMap(groupedNodes =>
         sortNodesByGroups.sortNodesByGroups({
-          getOptionsByGroupNumber: groupNumber => {
+          getOptionsByGroupIndex: groupIndex => {
             let {
               fallbackSortNodeValueGetter,
               options: overriddenOptions,
               nodeValueGetter,
             } = getCustomGroupsCompareOptions.getCustomGroupsCompareOptions(
               options,
-              groupNumber,
+              groupIndex,
             )
             return {
               options: {

package/dist/rules/sort-objects.js

@@ -297,7 +297,10 @@ const sortObjects = createEslintRule.createEslintRule({
             ) {
               accumulator.push([])
             }
-            accumulator.at(-1).push(sortingNode)
+            accumulator.at(-1).push({
+              ...sortingNode,
+              partitionId: accumulator.length,
+            })
             return accumulator
           },
           [[]],
@@ -319,7 +322,7 @@ const sortObjects = createEslintRule.createEslintRule({
                 nodes: nodes2,
               })
             : sortNodesByGroups.sortNodesByGroups({
-                getOptionsByGroupNumber:
+                getOptionsByGroupIndex:
                   getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
                     options,
                   ),

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

@@ -48,8 +48,10 @@ const sortSwitchCase = createEslintRule.createEslintRule({
             accumulator.at(-1).push({
               size: rangeToDiff.rangeToDiff(caseNode.test, sourceCode),
               name: getCaseName(sourceCode, caseNode),
+              partitionId: accumulator.length,
               isEslintDisabled: false,
               node: caseNode.test,
+              group: 'unknown',
             })
           }
           if (
@@ -104,6 +106,8 @@ const sortSwitchCase = createEslintRule.createEslintRule({
         addSafetySemicolonWhenInline: true,
         isDefaultClause: !caseNode.test,
         isEslintDisabled: false,
+        group: 'unknown',
+        partitionId: 0,
         node: caseNode,
       }))
       let sortingNodeGroupsForDefaultSort = reduceCaseSortingNodes(

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

@@ -217,7 +217,12 @@ let sortUnionOrIntersectionTypes = ({
         lastGroup = []
         accumulator.push(lastGroup)
       }
-      lastGroup == null ? void 0 : lastGroup.push(sortingNode)
+      lastGroup == null
+        ? void 0
+        : lastGroup.push({
+            ...sortingNode,
+            partitionId: accumulator.length,
+          })
       return accumulator
     },
     [[]],
@@ -225,7 +230,7 @@ let sortUnionOrIntersectionTypes = ({
   for (let nodes of formattedMembers) {
     let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
       sortNodesByGroups.sortNodesByGroups({
-        getOptionsByGroupNumber:
+        getOptionsByGroupIndex:
           getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
             options,
           ),

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

@@ -115,7 +115,12 @@ const sortVariableDeclarations = createEslintRule.createEslintRule({
           ) {
             accumulator.push([])
           }
-          ;(_b = accumulator.at(-1)) == null ? void 0 : _b.push(sortingNode)
+          ;(_b = accumulator.at(-1)) == null
+            ? void 0
+            : _b.push({
+                ...sortingNode,
+                partitionId: accumulator.length,
+              })
           return accumulator
         },
         [[]],
@@ -123,7 +128,7 @@ const sortVariableDeclarations = createEslintRule.createEslintRule({
       let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes => {
         let nodesSortedByGroups = formattedMembers.flatMap(nodes2 =>
           sortNodesByGroups.sortNodesByGroups({
-            getOptionsByGroupNumber:
+            getOptionsByGroupIndex:
               getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
                 options,
               ),

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

@@ -64,9 +64,17 @@ let buildCommonJsonSchemas = ({ additionalFallbackSortProperties } = {}) => ({
 })
 let commonJsonSchemas = buildCommonJsonSchemas()
 let newlinesBetweenJsonSchema = {
-  description: 'Specifies how to handle new lines between groups.',
-  enum: ['ignore', 'always', 'never'],
-  type: 'string',
+  oneOf: [
+    {
+      description: 'Specifies how to handle newlines between groups.',
+      enum: ['ignore', 'always', 'never'],
+      type: 'string',
+    },
+    {
+      type: 'number',
+      minimum: 0,
+    },
+  ],
 }
 let commentAboveJsonSchema = {
   description: 'Specifies a comment to enforce above the group.',
@@ -198,10 +206,18 @@ let buildCommonCustomGroupJsonSchemas = ({
   additionalFallbackSortProperties,
 } = {}) => ({
   newlinesInside: {
-    description:
-      'Specifies how to handle new lines between members of the custom group.',
-    enum: ['always', 'never'],
-    type: 'string',
+    oneOf: [
+      {
+        description:
+          'Specifies how to handle newlines between members of the custom group.',
+        enum: ['always', 'never'],
+        type: 'string',
+      },
+      {
+        type: 'number',
+        minimum: 0,
+      },
+    ],
   },
   fallbackSort: buildFallbackSortJsonSchema({
     additionalProperties: additionalFallbackSortProperties,

package/dist/utils/compare.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 const naturalOrderby = require('natural-orderby')
 const convertBooleanToSign = require('./convert-boolean-to-sign.js')
+const unreachableCaseError = require('./unreachable-case-error.js')
 let alphabetCache = /* @__PURE__ */ new Map()
 let compare = ({
   fallbackSortNodeValueGetter,
@@ -42,7 +43,7 @@ let computeCompareValue = ({ nodeValueGetter, options, a, b }) => {
       sortingFunction = getAlphabeticalSortingFunction(options, nodeValueGetter)
       break
     case 'line-length':
-      sortingFunction = getLineLengthSortingFunction(options, nodeValueGetter)
+      sortingFunction = getLineLengthSortingFunction()
       break
     case 'unsorted':
       return 0
@@ -52,6 +53,9 @@ let computeCompareValue = ({ nodeValueGetter, options, a, b }) => {
     case 'custom':
       sortingFunction = getCustomSortingFunction(options, nodeValueGetter)
       break
+    /* v8 ignore next 2 */
+    default:
+      throw new unreachableCaseError.UnreachableCaseError(options.type)
   }
   return (
     convertBooleanToSign.convertBooleanToSign(options.order === 'asc') *
@@ -121,23 +125,11 @@ let getCustomSortingFunction = (
     )
   }
 }
-let getLineLengthSortingFunction =
-  ({ maxLineLength }, nodeValueGetter) =>
-  (aNode, bNode) => {
-    let aSize = aNode.size
-    let bSize = bNode.size
-    if (maxLineLength) {
-      let isTooLong = (size, node) =>
-        size > maxLineLength && node.hasMultipleImportDeclarations
-      if (isTooLong(aSize, aNode)) {
-        aSize = nodeValueGetter(aNode).length + 10
-      }
-      if (isTooLong(bSize, bNode)) {
-        bSize = nodeValueGetter(bNode).length + 10
-      }
-    }
-    return aSize - bSize
-  }
+let getLineLengthSortingFunction = () => (aNode, bNode) => {
+  let aSize = aNode.size
+  let bSize = bNode.size
+  return aSize - bSize
+}
 let getFormatStringFunction = (ignoreCase, specialCharacters) => value => {
   let valueToCompare = value
   if (ignoreCase) {
@@ -156,6 +148,11 @@ let getFormatStringFunction = (ignoreCase, specialCharacters) => value => {
         '',
       )
       break
+    case 'keep':
+      break
+    /* v8 ignore next 2 */
+    default:
+      throw new unreachableCaseError.UnreachableCaseError(specialCharacters)
   }
   return valueToCompare.replaceAll(/\s/gu, '')
 }

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

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

package/dist/utils/get-eslint-disabled-lines.js

@@ -1,6 +1,7 @@
 'use strict'
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 const getEslintDisabledRules = require('./get-eslint-disabled-rules.js')
+const unreachableCaseError = require('./unreachable-case-error.js')
 let getEslintDisabledLines = props => {
   let { sourceCode, ruleName } = props
   let returnValue = []
@@ -9,20 +10,16 @@ let getEslintDisabledLines = props => {
     let eslintDisabledRules = getEslintDisabledRules.getEslintDisabledRules(
       comment.value,
     )
+    if (!eslintDisabledRules) {
+      continue
+    }
     let includesRule =
-      (eslintDisabledRules == null ? void 0 : eslintDisabledRules.rules) ===
-        'all' ||
-      (eslintDisabledRules == null
-        ? void 0
-        : eslintDisabledRules.rules.includes(ruleName))
+      eslintDisabledRules.rules === 'all' ||
+      eslintDisabledRules.rules.includes(ruleName)
     if (!includesRule) {
       continue
     }
-    switch (
-      eslintDisabledRules == null
-        ? void 0
-        : eslintDisabledRules.eslintDisableDirective
-    ) {
+    switch (eslintDisabledRules.eslintDisableDirective) {
       case 'eslint-disable-next-line':
         returnValue.push(comment.loc.end.line + 1)
         continue
@@ -45,6 +42,11 @@ let getEslintDisabledLines = props => {
         )
         lineRulePermanentlyDisabled = null
         break
+      /* v8 ignore next 4 */
+      default:
+        throw new unreachableCaseError.UnreachableCaseError(
+          eslintDisabledRules.eslintDisableDirective,
+        )
     }
   }
   return returnValue

package/dist/utils/get-newlines-between-errors.js

@@ -13,9 +13,15 @@ let getNewlinesBetweenErrors = ({
   right,
   left,
 }) => {
+  if (
+    leftGroupIndex > rightGroupIndex ||
+    left.partitionId !== right.partitionId
+  ) {
+    return []
+  }
   let newlinesBetween = getNewlinesBetweenOption.getNewlinesBetweenOption({
-    nextSortingNode: right,
-    sortingNode: left,
+    nextNodeGroupIndex: rightGroupIndex,
+    nodeGroupIndex: leftGroupIndex,
     options,
   })
   newlinesBetween =
@@ -26,25 +32,19 @@ let getNewlinesBetweenErrors = ({
           right,
           left,
         })) ?? newlinesBetween
-  if (leftGroupIndex > rightGroupIndex) {
-    return []
-  }
   let numberOfEmptyLinesBetween = getLinesBetween.getLinesBetween(
     sourceCode,
     left,
     right,
   )
-  switch (newlinesBetween) {
-    case 'ignore':
-      return []
-    case 'never':
-      return numberOfEmptyLinesBetween > 0 ? [extraSpacingError] : []
-    case 'always':
-      if (numberOfEmptyLinesBetween === 0) {
-        return [missedSpacingError]
-      } else if (numberOfEmptyLinesBetween > 1) {
-        return [extraSpacingError]
-      }
+  if (newlinesBetween === 'ignore') {
+    return []
+  }
+  if (numberOfEmptyLinesBetween < newlinesBetween) {
+    return [missedSpacingError]
+  }
+  if (numberOfEmptyLinesBetween > newlinesBetween) {
+    return [extraSpacingError]
   }
   return []
 }

package/dist/utils/get-newlines-between-option.js

@@ -1,20 +1,19 @@
 'use strict'
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 const isNewlinesBetweenOption = require('./is-newlines-between-option.js')
-const getGroupIndex = require('./get-group-index.js')
-let getNewlinesBetweenOption = ({ nextSortingNode, sortingNode, options }) => {
-  let nodeGroupNumber = getGroupIndex.getGroupIndex(options.groups, sortingNode)
-  let nextNodeGroupNumber = getGroupIndex.getGroupIndex(
-    options.groups,
-    nextSortingNode,
-  )
+const unreachableCaseError = require('./unreachable-case-error.js')
+let getNewlinesBetweenOption = ({
+  nextNodeGroupIndex,
+  nodeGroupIndex,
+  options,
+}) => {
   let globalNewlinesBetweenOption = getGlobalNewlinesBetweenOption({
     newlinesBetween: options.newlinesBetween,
-    nextNodeGroupNumber,
-    nodeGroupNumber,
+    nextNodeGroupIndex,
+    nodeGroupIndex,
   })
-  let nodeGroup = options.groups[nodeGroupNumber]
-  let nextNodeGroup = options.groups[nextNodeGroupNumber]
+  let nodeGroup = options.groups[nodeGroupIndex]
+  let nextNodeGroup = options.groups[nextNodeGroupIndex]
   if (
     Array.isArray(options.customGroups) &&
     typeof nodeGroup === 'string' &&
@@ -32,19 +31,26 @@ let getNewlinesBetweenOption = ({ nextSortingNode, sortingNode, options }) => {
       nextNodeCustomGroup &&
       nodeCustomGroup.groupName === nextNodeCustomGroup.groupName
     ) {
-      return nodeCustomGroup.newlinesInside ?? globalNewlinesBetweenOption
+      if (nodeCustomGroup.newlinesInside !== void 0) {
+        return convertNewlinesBetweenOptionToNumber(
+          nodeCustomGroup.newlinesInside,
+        )
+      }
+      return globalNewlinesBetweenOption
     }
   }
-  if (nextNodeGroupNumber >= nodeGroupNumber + 2) {
-    if (nextNodeGroupNumber === nodeGroupNumber + 2) {
-      let groupBetween = options.groups[nodeGroupNumber + 1]
+  if (nextNodeGroupIndex >= nodeGroupIndex + 2) {
+    if (nextNodeGroupIndex === nodeGroupIndex + 2) {
+      let groupBetween = options.groups[nodeGroupIndex + 1]
       if (isNewlinesBetweenOption.isNewlinesBetweenOption(groupBetween)) {
-        return groupBetween.newlinesBetween
+        return convertNewlinesBetweenOptionToNumber(
+          groupBetween.newlinesBetween,
+        )
       }
     } else {
       let relevantGroups = options.groups.slice(
-        nodeGroupNumber,
-        nextNodeGroupNumber + 1,
+        nodeGroupIndex,
+        nextNodeGroupIndex + 1,
       )
       let groupsWithAllNewlinesBetween = buildGroupsWithAllNewlinesBetween(
         relevantGroups,
@@ -53,33 +59,43 @@ let getNewlinesBetweenOption = ({ nextSortingNode, sortingNode, options }) => {
       let newlinesBetweenOptions = new Set(
         groupsWithAllNewlinesBetween
           .filter(isNewlinesBetweenOption.isNewlinesBetweenOption)
-          .map(group => group.newlinesBetween),
+          .map(group => group.newlinesBetween)
+          .map(convertNewlinesBetweenOptionToNumber),
+      )
+      let numberNewlinesBetween = [...newlinesBetweenOptions].filter(
+        option => typeof option === 'number',
       )
-      if (newlinesBetweenOptions.has('always')) {
-        return 'always'
+      let maxNewlinesBetween =
+        numberNewlinesBetween.length > 0
+          ? Math.max(...numberNewlinesBetween)
+          : null
+      if (maxNewlinesBetween !== null && maxNewlinesBetween >= 1) {
+        return maxNewlinesBetween
       }
       if (newlinesBetweenOptions.has('ignore')) {
         return 'ignore'
       }
-      if (newlinesBetweenOptions.has('never')) {
-        return 'never'
+      if (maxNewlinesBetween === 0) {
+        return 0
       }
     }
   }
   return globalNewlinesBetweenOption
 }
 let getGlobalNewlinesBetweenOption = ({
-  nextNodeGroupNumber,
+  nextNodeGroupIndex,
   newlinesBetween,
-  nodeGroupNumber,
+  nodeGroupIndex,
 }) => {
-  if (newlinesBetween === 'ignore') {
+  let numberNewlinesBetween =
+    convertNewlinesBetweenOptionToNumber(newlinesBetween)
+  if (numberNewlinesBetween === 'ignore') {
     return 'ignore'
   }
-  if (newlinesBetween === 'never') {
-    return 'never'
+  if (nodeGroupIndex === nextNodeGroupIndex) {
+    return 0
   }
-  return nodeGroupNumber === nextNodeGroupNumber ? 'never' : 'always'
+  return numberNewlinesBetween
 }
 let buildGroupsWithAllNewlinesBetween = (
   groups,
@@ -94,11 +110,29 @@ let buildGroupsWithAllNewlinesBetween = (
         previousGroup &&
         !isNewlinesBetweenOption.isNewlinesBetweenOption(previousGroup)
       ) {
-        returnValue.push({ newlinesBetween: globalNewlinesBetweenOption })
+        returnValue.push({
+          newlinesBetween: globalNewlinesBetweenOption,
+        })
       }
     }
     returnValue.push(group)
   }
   return returnValue
 }
+let convertNewlinesBetweenOptionToNumber = newlinesBetween => {
+  if (typeof newlinesBetween === 'number') {
+    return newlinesBetween
+  }
+  switch (newlinesBetween) {
+    case 'ignore':
+      return 'ignore'
+    case 'always':
+      return 1
+    case 'never':
+      return 0
+    /* v8 ignore next 2 */
+    default:
+      throw new unreachableCaseError.UnreachableCaseError(newlinesBetween)
+  }
+}
 exports.getNewlinesBetweenOption = getNewlinesBetweenOption

package/dist/utils/make-fixes.js

@@ -31,7 +31,10 @@ let makeFixes = ({
   if (commentAfterFixes.length > 0) {
     return [...orderFixes, ...commentAfterFixes]
   }
-  if ((options == null ? void 0 : options.groups) && options.newlinesBetween) {
+  if (
+    (options == null ? void 0 : options.groups) &&
+    options.newlinesBetween !== void 0
+  ) {
     let newlinesFixes = makeNewlinesBetweenFixes.makeNewlinesBetweenFixes({
       options: {
         ...options,

package/dist/utils/make-newlines-between-fixes.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 const getNewlinesBetweenOption = require('./get-newlines-between-option.js')
 const getLinesBetween = require('./get-lines-between.js')
+const getGroupIndex = require('./get-group-index.js')
 const getNodeRange = require('./get-node-range.js')
 let makeNewlinesBetweenFixes = ({
   newlinesBetweenValueGetter,
@@ -17,9 +18,23 @@ let makeNewlinesBetweenFixes = ({
     let nextSortingNode = nodes.at(i + 1)
     let sortedSortingNode = sortedNodes.at(i)
     let nextSortedSortingNode = sortedNodes.at(i + 1)
+    if (sortedSortingNode.partitionId !== nextSortedSortingNode.partitionId) {
+      continue
+    }
+    let nodeGroupIndex = getGroupIndex.getGroupIndex(
+      options.groups,
+      sortedSortingNode,
+    )
+    let nextNodeGroupIndex = getGroupIndex.getGroupIndex(
+      options.groups,
+      nextSortedSortingNode,
+    )
+    if (nodeGroupIndex > nextNodeGroupIndex) {
+      continue
+    }
     let newlinesBetween = getNewlinesBetweenOption.getNewlinesBetweenOption({
-      nextSortingNode: nextSortedSortingNode,
-      sortingNode: sortedSortingNode,
+      nextNodeGroupIndex,
+      nodeGroupIndex,
       options,
     })
     newlinesBetween =
@@ -43,39 +58,50 @@ let makeNewlinesBetweenFixes = ({
         sourceCode,
       })
       .at(0)
-    let rangeToReplace = [currentNodeRange.at(1), nextNodeRangeStart]
-    let textBetweenNodes = sourceCode.text.slice(
-      currentNodeRange.at(1),
-      nextNodeRangeStart,
-    )
     let linesBetweenMembers = getLinesBetween.getLinesBetween(
       sourceCode,
       sortingNode,
       nextSortingNode,
     )
-    let rangeReplacement
-    if (newlinesBetween === 'never' && linesBetweenMembers !== 0) {
-      rangeReplacement = getStringWithoutInvalidNewlines(textBetweenNodes)
-    }
-    if (newlinesBetween === 'always' && linesBetweenMembers !== 1) {
-      rangeReplacement = addNewlineBeforeFirstNewline(
-        linesBetweenMembers > 1
-          ? getStringWithoutInvalidNewlines(textBetweenNodes)
-          : textBetweenNodes,
-      )
-      let isOnSameLine =
-        linesBetweenMembers === 0 &&
-        sortingNode.node.loc.end.line === nextSortingNode.node.loc.start.line
-      if (isOnSameLine) {
-        rangeReplacement = addNewlineBeforeFirstNewline(rangeReplacement)
-      }
+    if (linesBetweenMembers === newlinesBetween) {
+      continue
     }
+    let rangeToReplace = [currentNodeRange.at(1), nextNodeRangeStart]
+    let textBetweenNodes = sourceCode.text.slice(
+      currentNodeRange.at(1),
+      nextNodeRangeStart,
+    )
+    let rangeReplacement = computeRangeReplacement({
+      isOnSameLine:
+        sortingNode.node.loc.end.line === nextSortingNode.node.loc.start.line,
+      textBetweenNodes,
+      newlinesBetween,
+    })
     if (rangeReplacement) {
       fixes.push(fixer.replaceTextRange(rangeToReplace, rangeReplacement))
     }
   }
   return fixes
 }
+let computeRangeReplacement = ({
+  textBetweenNodes,
+  newlinesBetween,
+  isOnSameLine,
+}) => {
+  let textBetweenNodesWithoutInvalidNewlines =
+    getStringWithoutInvalidNewlines(textBetweenNodes)
+  if (newlinesBetween === 0) {
+    return textBetweenNodesWithoutInvalidNewlines
+  }
+  let rangeReplacement = textBetweenNodesWithoutInvalidNewlines
+  for (let index = 0; index < newlinesBetween; index++) {
+    rangeReplacement = addNewlineBeforeFirstNewline(rangeReplacement)
+  }
+  if (!isOnSameLine) {
+    return rangeReplacement
+  }
+  return addNewlineBeforeFirstNewline(rangeReplacement)
+}
 let getStringWithoutInvalidNewlines = value =>
   value.replaceAll(/\n\s*\n/gu, '\n').replaceAll(/\n+/gu, '\n')
 let addNewlineBeforeFirstNewline = value => {

package/dist/utils/pairwise.js

@@ -1,8 +1,7 @@
 'use strict'
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
-const isSortable = require('./is-sortable.js')
 let pairwise = (nodes, callback) => {
-  if (!isSortable.isSortable(nodes)) {
+  if (nodes.length === 0) {
     return
   }
   callback(null, nodes.at(0))

package/dist/utils/report-all-errors.js

@@ -68,7 +68,7 @@ let reportAllErrors = ({
     }
     if (
       left &&
-      options.newlinesBetween &&
+      options.newlinesBetween !== void 0 &&
       availableMessageIds.missedSpacingBetweenMembers &&
       availableMessageIds.extraSpacingBetweenMembers
     ) {

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

@@ -4,13 +4,13 @@ const getGroupIndex = require('./get-group-index.js')
 const sortNodes = require('./sort-nodes.js')
 let sortNodesByGroups = ({
   ignoreEslintDisabledNodes,
-  getOptionsByGroupNumber,
+  getOptionsByGroupIndex,
   isNodeIgnoredForGroup,
   isNodeIgnored,
   groups,
   nodes,
 }) => {
-  let nodesByNonIgnoredGroupNumber = {}
+  let nodesByNonIgnoredGroupIndex = {}
   let ignoredNodeIndices = []
   for (let [index, sortingNode] of nodes.entries()) {
     if (
@@ -20,18 +20,18 @@ let sortNodesByGroups = ({
       ignoredNodeIndices.push(index)
       continue
     }
-    let groupNumber = getGroupIndex.getGroupIndex(groups, sortingNode)
-    nodesByNonIgnoredGroupNumber[groupNumber] ??
-      (nodesByNonIgnoredGroupNumber[groupNumber] = [])
-    nodesByNonIgnoredGroupNumber[groupNumber].push(sortingNode)
+    let groupIndex = getGroupIndex.getGroupIndex(groups, sortingNode)
+    nodesByNonIgnoredGroupIndex[groupIndex] ??
+      (nodesByNonIgnoredGroupIndex[groupIndex] = [])
+    nodesByNonIgnoredGroupIndex[groupIndex].push(sortingNode)
   }
   let sortedNodes = []
-  for (let groupNumber of Object.keys(nodesByNonIgnoredGroupNumber).sort(
+  for (let groupIndex of Object.keys(nodesByNonIgnoredGroupIndex).sort(
     (a, b) => Number(a) - Number(b),
   )) {
     let { fallbackSortNodeValueGetter, nodeValueGetter, options } =
-      getOptionsByGroupNumber(Number(groupNumber))
-    let nodesToPush = nodesByNonIgnoredGroupNumber[Number(groupNumber)]
+      getOptionsByGroupIndex(Number(groupIndex))
+    let nodesToPush = nodesByNonIgnoredGroupIndex[Number(groupIndex)]
     let groupIgnoredNodes = new Set(
       nodesToPush.filter(node =>
         isNodeIgnoredForGroup == null

package/dist/utils/unreachable-case-error.js

@@ -0,0 +1,9 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+class UnreachableCaseError extends Error {
+  constructor(value) {
+    super(`Unreachable case: ${value}`)
+    this.name = 'UnreachableCaseError'
+  }
+}
+exports.UnreachableCaseError = UnreachableCaseError

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-perfectionist",
-  "version": "4.14.0",
+  "version": "4.15.0",
   "description": "ESLint plugin for sorting various data such as objects, imports, types, enums, JSX props, etc.",
   "keywords": [
     "eslint",
@@ -23,12 +23,14 @@
     },
     "./package.json": "./package.json"
   },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "./dist"
   ],
   "dependencies": {
-    "@typescript-eslint/types": "^8.33.1",
-    "@typescript-eslint/utils": "^8.33.1",
+    "@typescript-eslint/types": "^8.34.1",
+    "@typescript-eslint/utils": "^8.34.1",
     "natural-orderby": "^5.0.0"
   },
   "peerDependencies": {