eslint-plugin-perfectionist 4.14.0 → 4.15.1

package/dist/alphabet.d.ts

@@ -1,81 +1,108 @@
 /**
- * Utility class to build alphabets
+ * Manages a customizable alphabet for sorting operations.
+ *
+ * Provides methods to generate, modify, and sort alphabets based on various
+ * criteria including Unicode ranges, case prioritization, and locale-specific
+ * ordering. Used by the 'custom' sort type to define character precedence.
+ *
+ * The class supports:
+ *
+ * - Generating alphabets from strings or Unicode ranges
+ * - Case prioritization and manipulation
+ * - Character positioning and removal
+ * - Multiple sorting strategies (natural, locale, char code).
+ *
+ * @example
+ *   // Create a custom alphabet with specific character order
+ *   const alphabet = Alphabet.generateFrom('aAbBcC')
+ *     .prioritizeCase('uppercase')
+ *     .getCharacters()
+ *   // Returns: 'AaBbCc'
  */
 export declare class Alphabet {
-  private _characters
+  private characters
   private constructor()
   /**
    * Generates an alphabet from the given characters.
-   * @param {string|string[]} values - The characters to generate the alphabet from
-   * @returns {Alphabet} - The wrapped alphabet
+   *
+   * @param values - The characters to generate the alphabet from.
+   * @returns - The wrapped alphabet.
    */
   static generateFrom(values: string[] | string): Alphabet
   /**
    * Generates an alphabet containing relevant characters from the Unicode
    * standard. Contains the Unicode planes 0 and 1.
-   * @returns {Alphabet} - The generated alphabet
+   *
+   * @returns - The generated alphabet.
    */
   static generateRecommendedAlphabet(): Alphabet
   /**
    * Generates an alphabet containing all characters from the Unicode standard
-   * except for irrelevant Unicode planes.
-   * Contains the Unicode planes 0, 1, 2 and 3.
-   * @returns {Alphabet} - The generated alphabet
+   * except for irrelevant Unicode planes. Contains the Unicode planes 0, 1, 2
+   * and 3.
+   *
+   * @returns - The generated alphabet.
    */
   static generateCompleteAlphabet(): Alphabet
-  private static _convertCodepointToCharacter
+  private static getCharactersWithCase
   /**
    * Generates an alphabet containing relevant characters from the Unicode
    * standard.
-   * @param {number} maxCodePoint - The maximum code point to generate the
-   * alphabet to
-   * @returns {Alphabet} - The generated alphabet
+   *
+   * @param maxCodePoint - The maximum code point to generate the alphabet to.
+   * @returns - The generated alphabet.
    */
-  private static _generateAlphabetToRange
+  private static generateAlphabetToRange
   /**
-   * For each character with a lower and upper case, permutes the two cases
-   * so that the alphabet is ordered by the case priority entered.
-   * @param {string} casePriority - The case to prioritize
-   * @returns {Alphabet} - The same alphabet instance with the cases prioritized
+   * For each character with a lower and upper case, permutes the two cases so
+   * that the alphabet is ordered by the case priority entered.
+   *
    * @example
-   * Alphabet.generateFrom('aAbBcdCD')
-   * .prioritizeCase('uppercase') // Returns 'AaBbCDcd'.
+   *   Alphabet.generateFrom('aAbBcdCD').prioritizeCase('uppercase') // Returns 'AaBbCDcd'.
+   *
+   * @param casePriority - The case to prioritize.
+   * @returns - The same alphabet instance with the cases prioritized.
    */
   prioritizeCase(casePriority: 'lowercase' | 'uppercase'): this
   /**
    * Adds specific characters to the end of the alphabet.
-   * @param {string|string[]} values - The characters to push to the alphabet
-   * @returns {Alphabet} - The same alphabet instance without the specified
-   * characters
+   *
    * @example
-   * Alphabet.generateFrom('ab')
-   * .pushCharacters('cd')
-   * // Returns 'abcd'
+   *   Alphabet.generateFrom('ab').pushCharacters('cd')
+   *   // Returns 'abcd'
+   *
+   * @param values - The characters to push to the alphabet.
+   * @returns - The same alphabet instance without the specified characters.
    */
   pushCharacters(values: string[] | string): this
   /**
-   * Permutes characters with cases so that all characters with the entered case
-   * are put before the other characters.
-   * @param {string} caseToComeFirst - The case to put before the other
-   * characters
-   * @returns {Alphabet} - The same alphabet instance with all characters with
-   * case before all the characters with the other case
+   * Permutes characters with cases so that all characters with the entered
+   * case are put before the other characters.
+   *
+   * @param caseToComeFirst - The case to put before the other characters.
+   * @returns - The same alphabet instance with all characters with case
+   *   before all the characters with the other case.
    */
   placeAllWithCaseBeforeAllWithOtherCase(
     caseToComeFirst: 'uppercase' | 'lowercase',
   ): this
   /**
-   * Places a specific character right before another character in the alphabet.
-   * @param {object} params - The parameters for the operation
-   * @param {string} params.characterBefore - The character to come before
-   * characterAfter
-   * @param {string} params.characterAfter - The target character
-   * @returns {Alphabet} - The same alphabet instance with the specific
-   * character prioritized
+   * Places a specific character right before another character in the
+   * alphabet.
+   *
    * @example
-   * Alphabet.generateFrom('ab-cd/')
-   * .placeCharacterBefore({ characterBefore: '/', characterAfter: '-' })
-   * // Returns 'ab/-cd'
+   *   Alphabet.generateFrom('ab-cd/').placeCharacterBefore({
+   *     characterBefore: '/',
+   *     characterAfter: '-',
+   *   })
+   *   // Returns 'ab/-cd'
+   *
+   * @param params - The parameters for the operation.
+   * @param params.characterBefore - The character to come before
+   *   characterAfter.
+   * @param params.characterAfter - The target character.
+   * @returns - The same alphabet instance with the specific character
+   *   prioritized.
    */
   placeCharacterBefore({
     characterBefore,
@@ -85,17 +112,22 @@ export declare class Alphabet {
     characterAfter: string
   }): this
   /**
-   * Places a specific character right after another character in the alphabet.
-   * @param {object} params - The parameters for the operation
-   * @param {string} params.characterBefore - The target character
-   * @param {string} params.characterAfter - The character to come after
-   * characterBefore
-   * @returns {Alphabet} - The same alphabet instance with the specific
-   * character prioritized
+   * Places a specific character right after another character in the
+   * alphabet.
+   *
    * @example
-   * Alphabet.generateFrom('ab-cd/')
-   * .placeCharacterAfter({ characterBefore: '/', characterAfter: '-' })
-   * // Returns 'abcd/-'
+   *   Alphabet.generateFrom('ab-cd/').placeCharacterAfter({
+   *     characterBefore: '/',
+   *     characterAfter: '-',
+   *   })
+   *   // Returns 'abcd/-'
+   *
+   * @param params - The parameters for the operation.
+   * @param params.characterBefore - The target character.
+   * @param params.characterAfter - The character to come after
+   *   characterBefore.
+   * @returns - The same alphabet instance with the specific character
+   *   prioritized.
    */
   placeCharacterAfter({
     characterBefore,
@@ -106,70 +138,66 @@ export declare class Alphabet {
   }): this
   /**
    * Removes specific characters from the alphabet by their range.
-   * @param {object} range - The Unicode range to remove characters from
-   * @param {number} range.start - The starting Unicode codepoint
-   * @param {number} range.end - The ending Unicode codepoint
-   * @returns {Alphabet} - The same alphabet instance without the characters
-   * from the specified range
+   *
+   * @param range - The Unicode range to remove characters from.
+   * @param range.start - The starting Unicode codepoint.
+   * @param range.end - The ending Unicode codepoint.
+   * @returns - The same alphabet instance without the characters from the
+   *   specified range.
    */
   removeUnicodeRange({ start, end }: { start: number; end: number }): this
   /**
    * Sorts the alphabet by the sorting function provided.
-   * @param {Function} sortingFunction - The sorting function to use
-   * @returns {Alphabet} - The same alphabet instance sorted by the sorting function provided
+   *
+   * @param sortingFunction - The sorting function to use.
+   * @returns - The same alphabet instance sorted by the sorting function
+   *   provided.
    */
   sortBy(
     sortingFunction: (characterA: string, characterB: string) => number,
   ): this
-  /**
-   * Removes specific characters from the alphabet.
-   * @param {string|string[]} values - The characters to remove from the
-   * alphabet
-   * @returns {Alphabet} - The same alphabet instance without the specified
-   * characters
-   * @example
-   * Alphabet.generateFrom('abcd')
-   * .removeCharacters('dcc')
-   * // Returns 'ab'
-   */
-  removeCharacters(values: string[] | string): this
   /**
    * Sorts the alphabet by the natural order of the characters using
    * `natural-orderby`.
-   * @param {string} locale - The locale to use for sorting
-   * @returns {Alphabet} - The same alphabet instance sorted by the natural
-   * order of the characters
+   *
+   * @param locale - The locale to use for sorting.
+   * @returns - The same alphabet instance sorted by the natural order of the
+   *   characters.
    */
   sortByNaturalSort(locale?: string): this
+  /**
+   * Removes specific characters from the alphabet.
+   *
+   * @example
+   *   Alphabet.generateFrom('abcd').removeCharacters('dcc')
+   *   // Returns 'ab'
+   *
+   * @param values - The characters to remove from the alphabet.
+   * @returns - The same alphabet instance without the specified characters.
+   */
+  removeCharacters(values: string[] | string): this
   /**
    * Sorts the alphabet by the character code point.
-   * @returns {Alphabet} - The same alphabet instance sorted by the character
-   * code point
+   *
+   * @returns - The same alphabet instance sorted by the character code point.
    */
   sortByCharCodeAt(): this
   /**
    * Sorts the alphabet by the locale order of the characters.
-   * @param {Intl.LocalesArgument} locales - The locales to use for sorting
-   * @returns {Alphabet} - The same alphabet instance sorted by the locale
-   * order of the characters
+   *
+   * @param locales - The locales to use for sorting.
+   * @returns - The same alphabet instance sorted by the locale order of the
+   *   characters.
    */
   sortByLocaleCompare(locales?: Intl.LocalesArgument): this
   /**
    * Retrieves the characters from the alphabet.
-   * @returns {string} The characters from the alphabet
+   *
+   * @returns The characters from the alphabet.
    */
   getCharacters(): string
-  /**
-   * Reverses the alphabet.
-   * @returns {Alphabet} - The same alphabet instance reversed
-   * @example
-   * Alphabet.generateFrom('ab')
-   * .reverse()
-   * // Returns 'ba'
-   */
-  reverse(): this
-  private _placeCharacterBeforeOrAfter
-  private _getCharactersWithCase
+  private placeCharacterBeforeOrAfter
+  private getCharactersWithCase
 }
 
 export {}

package/dist/index.js

@@ -49,23 +49,28 @@ let plugin = {
     name: _package.name,
   },
 }
-let getRules = options =>
-  Object.fromEntries(
+function getRules(options) {
+  return Object.fromEntries(
     Object.keys(plugin.rules).map(ruleName => [
       `${pluginName}/${ruleName}`,
       ['error', options],
     ]),
   )
-let createConfig = options => ({
-  plugins: {
-    [pluginName]: plugin,
-  },
-  rules: getRules(options),
-})
-let createLegacyConfig = options => ({
-  rules: getRules(options),
-  plugins: [pluginName],
-})
+}
+function createConfig(options) {
+  return {
+    plugins: {
+      [pluginName]: plugin,
+    },
+    rules: getRules(options),
+  }
+}
+function createLegacyConfig(options) {
+  return {
+    rules: getRules(options),
+    plugins: [pluginName],
+  }
+}
 const index = {
   ...plugin,
   configs: {

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.1'
 exports.name = name
 exports.version = version

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

@@ -113,7 +113,7 @@ const sortArrayIncludes = createEslintRule.createEslintRule({
   defaultOptions: [defaultOptions],
   name: 'sort-array-includes',
 })
-let sortArray = ({ availableMessageIds, elements, context }) => {
+function sortArray({ availableMessageIds, elements, context }) {
   if (!isSortable.isSortable(elements)) {
     return
   }
@@ -146,7 +146,6 @@ let sortArray = ({ availableMessageIds, elements, context }) => {
   })
   let formattedMembers = elements.reduce(
     (accumulator, element) => {
-      var _a
       if (element === null) {
         return accumulator
       }
@@ -187,8 +186,7 @@ let sortArray = ({ availableMessageIds, elements, context }) => {
         group,
         name,
       }
-      let lastSortingNode =
-        (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1)
+      let lastSortingNode = accumulator.at(-1)?.at(-1)
       if (
         shouldPartition.shouldPartition({
           lastSortingNode,
@@ -199,7 +197,10 @@ let sortArray = ({ availableMessageIds, elements, context }) => {
       ) {
         accumulator.push([])
       }
-      accumulator.at(-1).push(sortingNode)
+      accumulator.at(-1).push({
+        ...sortingNode,
+        partitionId: accumulator.length,
+      })
       return accumulator
     },
     [[]],
@@ -213,16 +214,12 @@ let sortArray = ({ availableMessageIds, elements, context }) => {
     groupKindOrder = ['any']
   }
   for (let nodes of formattedMembers) {
-    let filteredGroupKindNodes = groupKindOrder.map(groupKind =>
-      nodes.filter(
-        currentNode =>
-          groupKind === 'any' || currentNode.groupKind === groupKind,
-      ),
-    )
-    let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
-      filteredGroupKindNodes.flatMap(groupedNodes =>
+    let sortNodesExcludingEslintDisabled = function (
+      ignoreEslintDisabledNodes,
+    ) {
+      return filteredGroupKindNodes.flatMap(groupedNodes =>
         sortNodesByGroups.sortNodesByGroups({
-          getOptionsByGroupNumber:
+          getOptionsByGroupIndex:
             getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
               options,
             ),
@@ -231,6 +228,13 @@ let sortArray = ({ availableMessageIds, elements, context }) => {
           nodes: groupedNodes,
         }),
       )
+    }
+    let filteredGroupKindNodes = groupKindOrder.map(groupKind =>
+      nodes.filter(
+        currentNode =>
+          groupKind === 'any' || currentNode.groupKind === groupKind,
+      ),
+    )
     reportAllErrors.reportAllErrors({
       sortNodesExcludingEslintDisabled,
       availableMessageIds,
@@ -241,8 +245,11 @@ let sortArray = ({ availableMessageIds, elements, context }) => {
     })
   }
 }
-let getNodeName = ({ sourceCode, element }) =>
-  element.type === 'Literal' ? `${element.value}` : sourceCode.getText(element)
+function getNodeName({ sourceCode, element }) {
+  return element.type === 'Literal'
+    ? `${element.value}`
+    : sourceCode.getText(element)
+}
 exports.default = sortArrayIncludes
 exports.defaultOptions = defaultOptions
 exports.jsonSchema = jsonSchema

package/dist/rules/sort-classes/get-overload-signature-groups.js

@@ -1,7 +1,7 @@
 'use strict'
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 const isSortable = require('../../utils/is-sortable.js')
-let getOverloadSignatureGroups = members => {
+function getOverloadSignatureGroups(members) {
   let methods = members
     .filter(
       member =>

package/dist/rules/sort-classes.js

@@ -67,7 +67,6 @@ let defaultOptions = {
 const sortClasses = createEslintRule.createEslintRule({
   create: context => ({
     ClassBody: node => {
-      var _a
       if (!isSortable.isSortable(node.body)) {
         return
       }
@@ -93,9 +92,10 @@ const sortClasses = createEslintRule.createEslintRule({
         ruleName: id,
         sourceCode,
       })
-      let className = (_a = node.parent.id) == null ? void 0 : _a.name
-      let getDependencyName = props =>
-        `${props.isStatic ? 'static ' : ''}${props.isPrivateHash ? '#' : ''}${props.nodeNameWithoutStartingHash}`
+      let className = node.parent.id?.name
+      function getDependencyName(props) {
+        return `${props.isStatic ? 'static ' : ''}${props.isPrivateHash ? '#' : ''}${props.nodeNameWithoutStartingHash}`
+      }
       let classMethodsDependencyNames = new Set(
         node.body
           .map(member => {
@@ -114,9 +114,9 @@ const sortClasses = createEslintRule.createEslintRule({
           })
           .filter(Boolean),
       )
-      let extractDependencies = (expression, isMemberStatic) => {
+      function extractDependencies(expression, isMemberStatic) {
         let dependencies = []
-        let checkNode = nodeValue => {
+        function checkNode(nodeValue) {
           if (
             nodeValue.type === 'MemberExpression' &&
             (nodeValue.object.type === 'ThisExpression' ||
@@ -214,7 +214,7 @@ const sortClasses = createEslintRule.createEslintRule({
             }
           }
         }
-        let traverseNode = nodeValue => {
+        function traverseNode(nodeValue) {
           if (Array.isArray(nodeValue)) {
             for (let nodeItem of nodeValue) {
               traverseNode(nodeItem)
@@ -230,7 +230,6 @@ const sortClasses = createEslintRule.createEslintRule({
         getOverloadSignatureGroups.getOverloadSignatureGroups(node.body)
       let formattedNodes = node.body.reduce(
         (accumulator, member) => {
-          var _a2, _b, _c, _d, _e
           let name
           let dependencies = []
           if (member.type === 'StaticBlock') {
@@ -238,9 +237,7 @@ const sortClasses = createEslintRule.createEslintRule({
           } else if (member.type === 'TSIndexSignature') {
             name = sourceCode.text.slice(
               member.range.at(0),
-              ((_a2 = member.typeAnnotation) == null
-                ? void 0
-                : _a2.range.at(0)) ?? member.range.at(1),
+              member.typeAnnotation?.range.at(0) ?? member.range.at(1),
             )
           } else if (member.key.type === 'Identifier') {
             ;({ name } = member.key)
@@ -302,10 +299,8 @@ const sortClasses = createEslintRule.createEslintRule({
                 modifiers.push('optional')
               }
               if (
-                ((_b = member.value) == null ? void 0 : _b.type) ===
-                  'ArrowFunctionExpression' ||
-                ((_c = member.value) == null ? void 0 : _c.type) ===
-                  'FunctionExpression'
+                member.value?.type === 'ArrowFunctionExpression' ||
+                member.value?.type === 'FunctionExpression'
               ) {
                 if (member.value.async) {
                   modifiers.push('async')
@@ -419,10 +414,7 @@ const sortClasses = createEslintRule.createEslintRule({
               overloadSignatures.includes(member),
             )
           let overloadSignatureGroupMember =
-            (_d = overloadSignatureGroups[overloadSignatureGroupMemberIndex]) ==
-            null
-              ? void 0
-              : _d.at(-1)
+            overloadSignatureGroups[overloadSignatureGroupMemberIndex]?.at(-1)
           let sortingNode = {
             dependencyNames: [
               getDependencyName({
@@ -453,8 +445,7 @@ const sortClasses = createEslintRule.createEslintRule({
             group,
             name,
           }
-          let lastSortingNode =
-            (_e = accumulator.at(-1)) == null ? void 0 : _e.at(-1)
+          let lastSortingNode = accumulator.at(-1)?.at(-1)
           if (
             shouldPartition.shouldPartition({
               lastSortingNode,
@@ -465,18 +456,21 @@ const sortClasses = createEslintRule.createEslintRule({
           ) {
             accumulator.push([])
           }
-          accumulator.at(-1).push(sortingNode)
+          accumulator.at(-1).push({
+            ...sortingNode,
+            partitionId: accumulator.length,
+          })
           return accumulator
         },
         [[]],
       )
-      let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes => {
+      function sortNodesExcludingEslintDisabled(ignoreEslintDisabledNodes) {
         let nodesSortedByGroups = formattedNodes.flatMap(nodes2 =>
           sortNodesByGroups.sortNodesByGroups({
             isNodeIgnored: sortingNode =>
               getGroupIndex.getGroupIndex(options.groups, sortingNode) ===
               options.groups.length,
-            getOptionsByGroupNumber:
+            getOptionsByGroupIndex:
               getCustomGroupsCompareOptions.buildGetCustomGroupOverriddenOptionsFunction(
                 options,
               ),
@@ -503,7 +497,7 @@ const sortClasses = createEslintRule.createEslintRule({
             left.overloadSignaturesGroupId !== null &&
             left.overloadSignaturesGroupId === right.overloadSignaturesGroupId
           ) {
-            return 'never'
+            return 0
           }
           return computedNewlinesBetween
         },

package/dist/rules/sort-decorators.js

@@ -151,7 +151,7 @@ const sortDecorators = createEslintRule.createEslintRule({
   defaultOptions: [defaultOptions],
   name: 'sort-decorators',
 })
-let sortDecorators$1 = (context, options, decorators) => {
+function sortDecorators$1(context, options, decorators) {
   if (!isSortable.isSortable(decorators)) {
     return
   }
@@ -162,7 +162,6 @@ let sortDecorators$1 = (context, options, decorators) => {
   })
   let formattedMembers = decorators.reduce(
     (accumulator, decorator) => {
-      var _a
       let name = getDecoratorName.getDecoratorName({
         sourceCode,
         decorator,
@@ -182,8 +181,7 @@ let sortDecorators$1 = (context, options, decorators) => {
         group,
         name,
       }
-      let lastSortingNode =
-        (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1)
+      let lastSortingNode = accumulator.at(-1)?.at(-1)
       if (
         shouldPartition.shouldPartition({
           lastSortingNode,
@@ -194,20 +192,24 @@ let sortDecorators$1 = (context, options, decorators) => {
       ) {
         accumulator.push([])
       }
-      accumulator.at(-1).push(sortingNode)
+      accumulator.at(-1).push({
+        ...sortingNode,
+        partitionId: accumulator.length,
+      })
       return accumulator
     },
     [[]],
   )
-  let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
-    formattedMembers.flatMap(nodes2 =>
+  function sortNodesExcludingEslintDisabled(ignoreEslintDisabledNodes) {
+    return formattedMembers.flatMap(nodes2 =>
       sortNodesByGroups.sortNodesByGroups({
-        getOptionsByGroupNumber: () => ({ options }),
+        getOptionsByGroupIndex: () => ({ options }),
         ignoreEslintDisabledNodes,
         groups: options.groups,
         nodes: nodes2,
       }),
     )
+  }
   let nodes = formattedMembers.flat()
   reportAllErrors.reportAllErrors({
     availableMessageIds: {