eslint-plugin-perfectionist 4.15.1 → 5.1.0

package/dist/alphabet.d.ts

@@ -1,203 +1,2 @@
-/**
- * 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 constructor()
-  /**
-   * Generates an alphabet from the given characters.
-   *
-   * @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 - 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 - The generated alphabet.
-   */
-  static generateCompleteAlphabet(): Alphabet
-  private static getCharactersWithCase
-  /**
-   * Generates an alphabet containing relevant characters from the Unicode
-   * standard.
-   *
-   * @param maxCodePoint - The maximum code point to generate the alphabet to.
-   * @returns - The generated alphabet.
-   */
-  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.
-   *
-   * @example
-   *   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.
-   *
-   * @example
-   *   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 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.
-   *
-   * @example
-   *   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,
-    characterAfter,
-  }: {
-    characterBefore: string
-    characterAfter: string
-  }): this
-  /**
-   * Places a specific character right after another character in the
-   * alphabet.
-   *
-   * @example
-   *   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,
-    characterAfter,
-  }: {
-    characterBefore: string
-    characterAfter: string
-  }): this
-  /**
-   * Removes specific characters from the alphabet by their 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 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
-  /**
-   * Sorts the alphabet by the natural order of the characters using
-   * `natural-orderby`.
-   *
-   * @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 - The same alphabet instance sorted by the character code point.
-   */
-  sortByCharCodeAt(): this
-  /**
-   * Sorts the alphabet 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 The characters from the alphabet.
-   */
-  getCharacters(): string
-  private placeCharacterBeforeOrAfter
-  private getCharactersWithCase
-}
-
+export * from './utils/alphabet.js'
 export {}

package/dist/index.d.ts

@@ -1,46 +1,5 @@
-import { Linter } from 'eslint'
-import { Rule } from 'eslint'
-
-declare const _default: PluginConfig
-
-declare interface PluginConfig {
-  rules: {
-    'sort-variable-declarations': Rule.RuleModule
-    'sort-intersection-types': Rule.RuleModule
-    'sort-heritage-clauses': Rule.RuleModule
-    'sort-array-includes': Rule.RuleModule
-    'sort-named-imports': Rule.RuleModule
-    'sort-named-exports': Rule.RuleModule
-    'sort-object-types': Rule.RuleModule
-    'sort-union-types': Rule.RuleModule
-    'sort-switch-case': Rule.RuleModule
-    'sort-interfaces': Rule.RuleModule
-    'sort-decorators': Rule.RuleModule
-    'sort-jsx-props': Rule.RuleModule
-    'sort-modules': Rule.RuleModule
-    'sort-classes': Rule.RuleModule
-    'sort-imports': Rule.RuleModule
-    'sort-exports': Rule.RuleModule
-    'sort-objects': Rule.RuleModule
-    'sort-enums': Rule.RuleModule
-    'sort-sets': Rule.RuleModule
-    'sort-maps': Rule.RuleModule
-  }
-  configs: {
-    'recommended-alphabetical-legacy': Linter.LegacyConfig
-    'recommended-line-length-legacy': Linter.LegacyConfig
-    'recommended-natural-legacy': Linter.LegacyConfig
-    'recommended-custom-legacy': Linter.LegacyConfig
-    'recommended-alphabetical': Linter.Config
-    'recommended-line-length': Linter.Config
-    'recommended-natural': Linter.Config
-    'recommended-custom': Linter.Config
-  }
-  meta: {
-    version: string
-    name: string
-  }
-}
-
-export {}
-export = _default
+import { ESLint } from 'eslint'
+export declare let rules: ESLint.Plugin['rules']
+export declare let configs: ESLint.Plugin['configs']
+declare const _default: ESLint.Plugin
+export default _default

package/dist/index.js

@@ -1,53 +1,57 @@
-'use strict'
-const _package = require('./package.json.js')
-const sortVariableDeclarations = require('./rules/sort-variable-declarations.js')
-const sortIntersectionTypes = require('./rules/sort-intersection-types.js')
-const sortHeritageClauses = require('./rules/sort-heritage-clauses.js')
-const sortArrayIncludes = require('./rules/sort-array-includes.js')
-const sortNamedImports = require('./rules/sort-named-imports.js')
-const sortNamedExports = require('./rules/sort-named-exports.js')
-const sortObjectTypes = require('./rules/sort-object-types.js')
-const sortSwitchCase = require('./rules/sort-switch-case.js')
-const sortUnionTypes = require('./rules/sort-union-types.js')
-const sortInterfaces = require('./rules/sort-interfaces.js')
-const sortDecorators = require('./rules/sort-decorators.js')
-const sortJsxProps = require('./rules/sort-jsx-props.js')
-const sortClasses = require('./rules/sort-classes.js')
-const sortImports = require('./rules/sort-imports.js')
-const sortExports = require('./rules/sort-exports.js')
-const sortObjects = require('./rules/sort-objects.js')
-const sortModules = require('./rules/sort-modules.js')
-const sortEnums = require('./rules/sort-enums.js')
-const sortMaps = require('./rules/sort-maps.js')
-const sortSets = require('./rules/sort-sets.js')
+import { name, version } from './package.json.js'
+import sortVariableDeclarations from './rules/sort-variable-declarations.js'
+import sortIntersectionTypes from './rules/sort-intersection-types.js'
+import sortImportAttributes from './rules/sort-import-attributes.js'
+import sortExportAttributes from './rules/sort-export-attributes.js'
+import sortHeritageClauses from './rules/sort-heritage-clauses.js'
+import sortArrayIncludes from './rules/sort-array-includes.js'
+import sortNamedImports from './rules/sort-named-imports.js'
+import sortNamedExports from './rules/sort-named-exports.js'
+import sortObjectTypes from './rules/sort-object-types.js'
+import sortSwitchCase from './rules/sort-switch-case.js'
+import sortUnionTypes from './rules/sort-union-types.js'
+import sortInterfaces from './rules/sort-interfaces.js'
+import sortDecorators from './rules/sort-decorators.js'
+import sortJsxProps from './rules/sort-jsx-props.js'
+import sortClasses from './rules/sort-classes.js'
+import sortImports from './rules/sort-imports.js'
+import sortExports from './rules/sort-exports.js'
+import sortObjects from './rules/sort-objects.js'
+import sortModules from './rules/sort-modules.js'
+import sortEnums from './rules/sort-enums.js'
+import sortMaps from './rules/sort-maps.js'
+import sortSets from './rules/sort-sets.js'
 let pluginName = 'perfectionist'
+let rules = {
+  'sort-variable-declarations': sortVariableDeclarations,
+  'sort-intersection-types': sortIntersectionTypes,
+  'sort-import-attributes': sortImportAttributes,
+  'sort-export-attributes': sortExportAttributes,
+  'sort-heritage-clauses': sortHeritageClauses,
+  'sort-array-includes': sortArrayIncludes,
+  'sort-named-imports': sortNamedImports,
+  'sort-named-exports': sortNamedExports,
+  'sort-object-types': sortObjectTypes,
+  'sort-union-types': sortUnionTypes,
+  'sort-switch-case': sortSwitchCase,
+  'sort-decorators': sortDecorators,
+  'sort-interfaces': sortInterfaces,
+  'sort-jsx-props': sortJsxProps,
+  'sort-modules': sortModules,
+  'sort-classes': sortClasses,
+  'sort-imports': sortImports,
+  'sort-exports': sortExports,
+  'sort-objects': sortObjects,
+  'sort-enums': sortEnums,
+  'sort-sets': sortSets,
+  'sort-maps': sortMaps,
+}
 let plugin = {
-  rules: {
-    'sort-variable-declarations': sortVariableDeclarations,
-    'sort-intersection-types': sortIntersectionTypes,
-    'sort-heritage-clauses': sortHeritageClauses,
-    'sort-array-includes': sortArrayIncludes.default,
-    'sort-named-imports': sortNamedImports,
-    'sort-named-exports': sortNamedExports,
-    'sort-object-types': sortObjectTypes.default,
-    'sort-union-types': sortUnionTypes.default,
-    'sort-switch-case': sortSwitchCase,
-    'sort-decorators': sortDecorators,
-    'sort-interfaces': sortInterfaces,
-    'sort-jsx-props': sortJsxProps,
-    'sort-modules': sortModules,
-    'sort-classes': sortClasses,
-    'sort-imports': sortImports,
-    'sort-exports': sortExports,
-    'sort-objects': sortObjects,
-    'sort-enums': sortEnums,
-    'sort-sets': sortSets,
-    'sort-maps': sortMaps,
-  },
   meta: {
-    version: _package.version,
-    name: _package.name,
+    version,
+    name,
   },
+  rules,
 }
 function getRules(options) {
   return Object.fromEntries(
@@ -71,41 +75,42 @@ function createLegacyConfig(options) {
     plugins: [pluginName],
   }
 }
+let configs = {
+  'recommended-alphabetical-legacy': createLegacyConfig({
+    type: 'alphabetical',
+    order: 'asc',
+  }),
+  'recommended-line-length-legacy': createLegacyConfig({
+    type: 'line-length',
+    order: 'desc',
+  }),
+  'recommended-natural-legacy': createLegacyConfig({
+    type: 'natural',
+    order: 'asc',
+  }),
+  'recommended-custom-legacy': createLegacyConfig({
+    type: 'custom',
+    order: 'asc',
+  }),
+  'recommended-alphabetical': createConfig({
+    type: 'alphabetical',
+    order: 'asc',
+  }),
+  'recommended-line-length': createConfig({
+    type: 'line-length',
+    order: 'desc',
+  }),
+  'recommended-natural': createConfig({
+    type: 'natural',
+    order: 'asc',
+  }),
+  'recommended-custom': createConfig({
+    type: 'custom',
+    order: 'asc',
+  }),
+}
 const index = {
   ...plugin,
-  configs: {
-    'recommended-alphabetical-legacy': createLegacyConfig({
-      type: 'alphabetical',
-      order: 'asc',
-    }),
-    'recommended-line-length-legacy': createLegacyConfig({
-      type: 'line-length',
-      order: 'desc',
-    }),
-    'recommended-natural-legacy': createLegacyConfig({
-      type: 'natural',
-      order: 'asc',
-    }),
-    'recommended-custom-legacy': createLegacyConfig({
-      type: 'custom',
-      order: 'asc',
-    }),
-    'recommended-alphabetical': createConfig({
-      type: 'alphabetical',
-      order: 'asc',
-    }),
-    'recommended-line-length': createConfig({
-      type: 'line-length',
-      order: 'desc',
-    }),
-    'recommended-natural': createConfig({
-      type: 'natural',
-      order: 'asc',
-    }),
-    'recommended-custom': createConfig({
-      type: 'custom',
-      order: 'asc',
-    }),
-  },
+  configs,
 }
-module.exports = index
+export { configs, index as default, rules }

package/dist/package.json.js

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

package/dist/rules/sort-array-includes/types.d.ts

@@ -0,0 +1,70 @@
+import { JSONSchema4 } from '@typescript-eslint/utils/json-schema'
+import {
+  CommonOptions,
+  RegexOption,
+  TypeOption,
+} from '../../types/common-options.js'
+import { CommonPartitionOptions } from '../../types/common-partition-options.js'
+import { CommonGroupsOptions } from '../../types/common-groups-options.js'
+/**
+ * Configuration options for the sort-array-includes rule.
+ *
+ * This rule enforces the sorting of arrays passed to the `.includes()` method,
+ * ensuring consistent ordering of array elements for better readability and
+ * maintainability.
+ */
+export type Options = Partial<
+  {
+    /**
+     * Conditional configuration based on pattern matching. When specified, the
+     * rule applies only if all array element names match the given pattern.
+     */
+    useConfigurationIf: {
+      /**
+       * Regular expression pattern to match against all array element names.
+       * The rule is only applied when all names match this pattern.
+       */
+      allNamesMatchPattern?: RegexOption
+    }
+  } & CommonGroupsOptions<
+    SingleCustomGroup,
+    Record<string, never>,
+    TypeOption
+  > &
+    CommonOptions<TypeOption> &
+    CommonPartitionOptions
+>[]
+/**
+ * Represents the type of array element selector. Used to distinguish between
+ * literal values and spread elements in arrays.
+ */
+export type Selector = (typeof allSelectors)[number]
+/**
+ * Additional configuration for a single custom group.
+ *
+ * Custom groups allow fine-grained control over how array elements are grouped
+ * and sorted based on their names and types.
+ *
+ * @example
+ *   {
+ *     "selector": "literal"
+ *   }
+ */
+interface SingleCustomGroup {
+  /**
+   * Specifies the type of array elements to include in this group. Can be
+   * 'literal' for literal values or 'spread' for spread elements.
+   */
+  selector?: Selector
+}
+/**
+ * Complete list of available selectors for array elements. Used for validation
+ * and JSON schema generation.
+ */
+export declare let allSelectors: readonly ['literal', 'spread']
+/**
+ * JSON schema definition for validating single custom group configurations.
+ * Used by ESLint to validate rule options at configuration time.
+ */
+export declare let singleCustomGroupJsonSchema: Record<string, JSONSchema4>
+export {}

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

@@ -1,10 +1,6 @@
-'use strict'
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
-const commonJsonSchemas = require('../../utils/common-json-schemas.js')
+import { buildCustomGroupSelectorJsonSchema } from '../../utils/json-schemas/common-groups-json-schemas.js'
 let allSelectors = ['literal', 'spread']
 let singleCustomGroupJsonSchema = {
-  selector: commonJsonSchemas.buildCustomGroupSelectorJsonSchema(allSelectors),
-  elementNamePattern: commonJsonSchemas.regexJsonSchema,
+  selector: buildCustomGroupSelectorJsonSchema(allSelectors),
 }
-exports.allSelectors = allSelectors
-exports.singleCustomGroupJsonSchema = singleCustomGroupJsonSchema
+export { allSelectors, singleCustomGroupJsonSchema }

package/dist/rules/sort-array-includes.d.ts

@@ -0,0 +1,38 @@
+import { JSONSchema4 } from '@typescript-eslint/utils/json-schema'
+import { RuleContext } from '@typescript-eslint/utils/ts-eslint'
+import { TSESTree } from '@typescript-eslint/types'
+import { TSESLint } from '@typescript-eslint/utils'
+import { Options } from './sort-array-includes/types.js'
+declare const ORDER_ERROR_ID = 'unexpectedArrayIncludesOrder'
+declare const GROUP_ORDER_ERROR_ID = 'unexpectedArrayIncludesGroupOrder'
+declare const EXTRA_SPACING_ERROR_ID = 'extraSpacingBetweenArrayIncludesMembers'
+declare const MISSED_SPACING_ERROR_ID =
+  'missedSpacingBetweenArrayIncludesMembers'
+type MessageId =
+  | typeof MISSED_SPACING_ERROR_ID
+  | typeof EXTRA_SPACING_ERROR_ID
+  | typeof GROUP_ORDER_ERROR_ID
+  | typeof ORDER_ERROR_ID
+export declare let defaultOptions: Required<Options[number]>
+export declare let jsonSchema: JSONSchema4
+declare const _default: TSESLint.RuleModule<
+  MessageId,
+  Options,
+  import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
+  TSESLint.RuleListener
+>
+export default _default
+export declare function sortArray<MessageIds extends string>({
+  availableMessageIds,
+  elements,
+  context,
+}: {
+  availableMessageIds: {
+    missedSpacingBetweenMembers: MessageIds
+    extraSpacingBetweenMembers: MessageIds
+    unexpectedGroupOrder: MessageIds
+    unexpectedOrder: MessageIds
+  }
+  elements: (TSESTree.SpreadElement | TSESTree.Expression | null)[]
+  context: Readonly<RuleContext<MessageIds, Options>>
+}): void