eslint-plugin-perfectionist 5.1.0 → 5.2.0

package/dist/index.d.ts

@@ -1,5 +1,17 @@
-import { ESLint } from 'eslint'
+import { ESLint, Linter } from 'eslint'
+interface PluginConfigs {
+  '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
+}
 export declare let rules: ESLint.Plugin['rules']
-export declare let configs: ESLint.Plugin['configs']
-declare const _default: ESLint.Plugin
+export declare let configs: PluginConfigs
+declare const _default: {
+  configs: PluginConfigs
+} & ESLint.Plugin
 export default _default

package/dist/package.json.js

@@ -1,3 +1,3 @@
 const name = 'eslint-plugin-perfectionist'
-const version = '5.1.0'
+const version = '5.2.0'
 export { name, version }

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

@@ -20,7 +20,9 @@ declare const _default: TSESLint.RuleModule<
   Options,
   import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
   TSESLint.RuleListener
->
+> & {
+  name: string
+}
 export default _default
 export declare function sortArray<MessageIds extends string>({
   availableMessageIds,

package/dist/rules/sort-classes.d.ts

@@ -15,5 +15,7 @@ declare const _default: import('@typescript-eslint/utils/ts-eslint').RuleModule<
   SortClassesOptions,
   import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
   import('@typescript-eslint/utils/ts-eslint').RuleListener
->
+> & {
+  name: string
+}
 export default _default

package/dist/rules/sort-decorators.d.ts

@@ -13,5 +13,7 @@ declare const _default: import('@typescript-eslint/utils/ts-eslint').RuleModule<
   Options,
   import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
   import('@typescript-eslint/utils/ts-eslint').RuleListener
->
+> & {
+  name: string
+}
 export default _default

package/dist/rules/sort-enums.d.ts

@@ -15,5 +15,7 @@ declare const _default: import('@typescript-eslint/utils/ts-eslint').RuleModule<
   Options,
   import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
   import('@typescript-eslint/utils/ts-eslint').RuleListener
->
+> & {
+  name: string
+}
 export default _default

package/dist/rules/sort-export-attributes.d.ts

@@ -14,5 +14,7 @@ declare const _default: TSESLint.RuleModule<
   Options,
   import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
   TSESLint.RuleListener
->
+> & {
+  name: string
+}
 export default _default

package/dist/rules/sort-exports.d.ts

@@ -16,5 +16,7 @@ declare const _default: TSESLint.RuleModule<
   Options,
   import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
   TSESLint.RuleListener
->
+> & {
+  name: string
+}
 export default _default

package/dist/rules/sort-heritage-clauses.d.ts

@@ -13,5 +13,7 @@ declare const _default: import('@typescript-eslint/utils/ts-eslint').RuleModule<
   Options,
   import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
   import('@typescript-eslint/utils/ts-eslint').RuleListener
->
+> & {
+  name: string
+}
 export default _default

package/dist/rules/sort-import-attributes.d.ts

@@ -14,5 +14,7 @@ declare const _default: TSESLint.RuleModule<
   Options,
   import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
   TSESLint.RuleListener
->
+> & {
+  name: string
+}
 export default _default

package/dist/rules/sort-imports/comparator-by-options-computer.js

@@ -1,6 +1,11 @@
 import { defaultComparatorByOptionsComputer } from '../../utils/compare/default-comparator-by-options-computer.js'
+import { buildLineLengthComparator } from '../../utils/compare/build-line-length-comparator.js'
+import { compareAlphabetically } from '../../utils/compare/compare-alphabetically.js'
+import { compareByCustomSort } from '../../utils/compare/compare-by-custom-sort.js'
 import { computeOrderedValue } from '../../utils/compare/compute-ordered-value.js'
+import { unsortedComparator } from '../../utils/compare/unsorted-comparator.js'
 import { UnreachableCaseError } from '../../utils/unreachable-case-error.js'
+import { compareNaturally } from '../../utils/compare/compare-naturally.js'
 let comparatorByOptionsComputer = options => {
   switch (options.type) {
     case 'type-import-first':
@@ -10,10 +15,21 @@ let comparatorByOptionsComputer = options => {
     case 'unsorted':
     case 'natural':
     case 'custom':
-      return defaultComparatorByOptionsComputer({
-        ...options,
-        type: options.type,
-      })
+      switch (options.sortBy) {
+        case 'specifier':
+          return bySpecifierComparatorByOptionsComputer({
+            ...options,
+            type: options.type,
+          })
+        case 'path':
+          return defaultComparatorByOptionsComputer({
+            ...options,
+            type: options.type,
+          })
+        /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+        default:
+          throw new UnreachableCaseError(options.sortBy)
+      }
     /* v8 ignore next 2 -- @preserve Exhaustive guard. */
     default:
       throw new UnreachableCaseError(options.type)
@@ -28,4 +44,32 @@ function compareTypeImportFirst(a, b, options) {
   }
   return computeOrderedValue(a.isTypeImport ? -1 : 1, options.order)
 }
+let bySpecifierComparatorByOptionsComputer = options => {
+  switch (options.type) {
+    case 'alphabetical':
+      return (a, b) =>
+        compareAlphabetically(
+          a.specifierName ?? '',
+          b.specifierName ?? '',
+          options,
+        )
+    case 'line-length':
+      return buildLineLengthComparator(options)
+    case 'unsorted':
+      return unsortedComparator
+    case 'natural':
+      return (a, b) =>
+        compareNaturally(a.specifierName ?? '', b.specifierName ?? '', options)
+    case 'custom':
+      return (a, b) =>
+        compareByCustomSort(
+          a.specifierName ?? '',
+          b.specifierName ?? '',
+          options,
+        )
+    /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+    default:
+      throw new UnreachableCaseError(options.type)
+  }
+}
 export { comparatorByOptionsComputer }

package/dist/rules/sort-imports/compute-specifier-name.d.ts

@@ -0,0 +1,12 @@
+import { TSESLint } from '@typescript-eslint/utils'
+import { TSESTree } from '@typescript-eslint/types'
+export declare function computeSpecifierName({
+  sourceCode,
+  node,
+}: {
+  node:
+    | TSESTree.TSImportEqualsDeclaration
+    | TSESTree.VariableDeclaration
+    | TSESTree.ImportDeclaration
+  sourceCode: TSESLint.SourceCode
+}): string | null

package/dist/rules/sort-imports/compute-specifier-name.js

@@ -0,0 +1,64 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import { UnreachableCaseError } from '../../utils/unreachable-case-error.js'
+function computeSpecifierName({ sourceCode, node }) {
+  switch (node.type) {
+    case AST_NODE_TYPES.TSImportEqualsDeclaration:
+      return node.id.name
+    case AST_NODE_TYPES.VariableDeclaration:
+      return computeVariableDeclarationSpecifierName(node, sourceCode)
+    case AST_NODE_TYPES.ImportDeclaration:
+      return computeImportDeclarationSpecifierName(node)
+    /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+    default:
+      throw new UnreachableCaseError(node)
+  }
+}
+function computeVariableDeclarationSpecifierName(node, sourceCode) {
+  let [declaration] = node.declarations
+  switch (declaration.id.type) {
+    case AST_NODE_TYPES.ObjectPattern:
+      return computeObjectPatternPropertyName(declaration.id.properties[0])
+    case AST_NODE_TYPES.ArrayPattern:
+      if (!declaration.id.elements[0]) {
+        return null
+      }
+      return sourceCode.getText(declaration.id.elements[0])
+    case AST_NODE_TYPES.Identifier:
+      return declaration.id.name
+    /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+    default:
+      throw new UnreachableCaseError(declaration.id)
+  }
+  function computeObjectPatternPropertyName(property) {
+    if (!property) {
+      return null
+    }
+    switch (property.type) {
+      case AST_NODE_TYPES.RestElement:
+        return sourceCode.getText(property.argument)
+      case AST_NODE_TYPES.Property:
+        return sourceCode.getText(property.value)
+      /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+      default:
+        throw new UnreachableCaseError(property)
+    }
+  }
+}
+function computeImportDeclarationSpecifierName(node) {
+  let [specifier] = node.specifiers
+  if (!specifier) {
+    return null
+  }
+  switch (specifier.type) {
+    case AST_NODE_TYPES.ImportNamespaceSpecifier:
+      return specifier.local.name
+    case AST_NODE_TYPES.ImportDefaultSpecifier:
+      return specifier.local.name
+    case AST_NODE_TYPES.ImportSpecifier:
+      return specifier.local.name
+    /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+    default:
+      throw new UnreachableCaseError(specifier)
+  }
+}
+export { computeSpecifierName }

package/dist/rules/sort-imports/types.d.ts

@@ -55,10 +55,17 @@ export type Options = Partial<
     maxLineLength: number
   } & CommonGroupsOptions<
     SingleCustomGroup,
-    Record<string, never>,
+    {
+      sortBy: 'specifier' | 'path'
+    },
     CustomTypeOption
   > &
-    CommonOptions<CustomTypeOption> &
+    CommonOptions<
+      CustomTypeOption,
+      {
+        sortBy: 'specifier' | 'path'
+      }
+    > &
     CommonPartitionOptions
 >[]
 /**
@@ -70,6 +77,8 @@ export interface SortImportsSortingNode extends SortingNodeWithDependencies<
   | TSESTree.VariableDeclaration
   | TSESTree.ImportDeclaration
 > {
+  /** The name of the import specifier for sorting purposes. */
+  specifierName: string | null
   /** Whether this import is a type-only import. */
   isTypeImport: boolean
   /**
@@ -144,5 +153,6 @@ export declare let allModifiers: readonly [
  * ensure that users do not enter invalid modifiers for a given selector.
  */
 export declare let singleCustomGroupJsonSchema: Record<string, JSONSchema4>
+export declare let sortByJsonSchema: JSONSchema4
 export declare const TYPE_IMPORT_FIRST_TYPE_OPTION = 'type-import-first'
 export {}

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

@@ -33,10 +33,15 @@ let singleCustomGroupJsonSchema = {
   modifiers: buildCustomGroupModifiersJsonSchema(allModifiers),
   selector: buildCustomGroupSelectorJsonSchema(allSelectors),
 }
+let sortByJsonSchema = {
+  enum: ['specifier', 'path'],
+  type: 'string',
+}
 const TYPE_IMPORT_FIRST_TYPE_OPTION = 'type-import-first'
 export {
   TYPE_IMPORT_FIRST_TYPE_OPTION,
   allModifiers,
   allSelectors,
   singleCustomGroupJsonSchema,
+  sortByJsonSchema,
 }

package/dist/rules/sort-imports.d.ts

@@ -18,5 +18,7 @@ declare const _default: TSESLint.RuleModule<
   Options,
   import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
   TSESLint.RuleListener
->
+> & {
+  name: string
+}
 export default _default

package/dist/rules/sort-imports.js

@@ -9,6 +9,7 @@ import {
 import {
   singleCustomGroupJsonSchema,
   TYPE_IMPORT_FIRST_TYPE_OPTION,
+  sortByJsonSchema,
   allSelectors,
   allModifiers,
 } from './sort-imports/types.js'
@@ -36,6 +37,7 @@ import { isSideEffectOnlyGroup } from './sort-imports/is-side-effect-only-group.
 import { computeDependencyNames } from './sort-imports/compute-dependency-names.js'
 import { generatePredefinedGroups } from '../utils/generate-predefined-groups.js'
 import { sortNodesByDependencies } from '../utils/sort-nodes-by-dependencies.js'
+import { computeSpecifierName } from './sort-imports/compute-specifier-name.js'
 import { getEslintDisabledLines } from '../utils/get-eslint-disabled-lines.js'
 import { computeDependencies } from './sort-imports/compute-dependencies.js'
 import { isSideEffectImport } from './sort-imports/is-side-effect-import.js'
@@ -85,6 +87,7 @@ let defaultOptions = {
   customGroups: [],
   ignoreCase: true,
   locales: 'en-US',
+  sortBy: 'path',
   alphabet: '',
   order: 'asc',
 }
@@ -193,6 +196,7 @@ const sortImports = createEslintRule({
           (!isStyleSideEffect || !shouldRegroupSideEffectStyleNodes),
         isEslintDisabled: isNodeEslintDisabled(node, eslintDisabledLines),
         dependencyNames: computeDependencyNames({ sourceCode, node }),
+        specifierName: computeSpecifierName({ sourceCode, node }),
         isTypeImport: modifiers.includes('type'),
         dependencies: computeDependencies(node),
         addSafetySemicolonWhenInline: true,
@@ -230,9 +234,11 @@ const sortImports = createEslintRule({
         properties: {
           ...buildCommonJsonSchemas({
             allowedAdditionalTypeValues: [TYPE_IMPORT_FIRST_TYPE_OPTION],
+            additionalSortProperties: { sortBy: sortByJsonSchema },
           }),
           ...buildCommonGroupsJsonSchemas({
             allowedAdditionalTypeValues: [TYPE_IMPORT_FIRST_TYPE_OPTION],
+            additionalSortProperties: { sortBy: sortByJsonSchema },
             singleCustomGroupJsonSchema,
           }),
           tsconfig: {

package/dist/rules/sort-interfaces.d.ts

@@ -13,5 +13,7 @@ declare const _default: import('@typescript-eslint/utils/ts-eslint').RuleModule<
   SortObjectTypesOptions,
   import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
   import('@typescript-eslint/utils/ts-eslint').RuleListener
->
+> & {
+  name: string
+}
 export default _default

package/dist/rules/sort-intersection-types.d.ts

@@ -13,5 +13,7 @@ declare const _default: import('@typescript-eslint/utils/ts-eslint').RuleModule<
   SortUnionTypesOptions,
   import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
   import('@typescript-eslint/utils/ts-eslint').RuleListener
->
+> & {
+  name: string
+}
 export default _default

package/dist/rules/sort-jsx-props.d.ts

@@ -14,5 +14,7 @@ declare const _default: TSESLint.RuleModule<
   Options,
   import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
   TSESLint.RuleListener
->
+> & {
+  name: string
+}
 export default _default

package/dist/rules/sort-maps.d.ts

@@ -14,5 +14,7 @@ declare const _default: TSESLint.RuleModule<
   Options,
   import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
   TSESLint.RuleListener
->
+> & {
+  name: string
+}
 export default _default

package/dist/rules/sort-modules/build-comparator-by-options-computer.d.ts

@@ -0,0 +1,12 @@
+import { ComparatorByOptionsComputer } from '../../utils/compare/default-comparator-by-options-computer.js'
+import { SortModulesSortingNode, SortModulesOptions } from './types.js'
+export declare function buildComparatorByOptionsComputer({
+  ignoreEslintDisabledNodes,
+  sortingNodes,
+}: {
+  sortingNodes: SortModulesSortingNode[]
+  ignoreEslintDisabledNodes: boolean
+}): ComparatorByOptionsComputer<
+  Required<SortModulesOptions[number]>,
+  SortModulesSortingNode
+>

package/dist/rules/sort-modules/build-comparator-by-options-computer.js

@@ -0,0 +1,66 @@
+import { defaultComparatorByOptionsComputer } from '../../utils/compare/default-comparator-by-options-computer.js'
+import { sortNodesByDependencies } from '../../utils/sort-nodes-by-dependencies.js'
+import { computeOrderedValue } from '../../utils/compare/compute-ordered-value.js'
+import { UnreachableCaseError } from '../../utils/unreachable-case-error.js'
+import { computeDependencies } from './compute-dependencies.js'
+function buildComparatorByOptionsComputer({
+  ignoreEslintDisabledNodes,
+  sortingNodes,
+}) {
+  return options => {
+    switch (options.type) {
+      case 'alphabetical':
+      case 'line-length':
+      case 'unsorted':
+      case 'natural':
+      case 'custom':
+        return defaultComparatorByOptionsComputer({
+          ...options,
+          type: options.type,
+        })
+      case 'usage':
+        return buildUsageComparator({
+          ignoreEslintDisabledNodes,
+          sortingNodes,
+          options,
+        })
+      /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+      default:
+        throw new UnreachableCaseError(options.type)
+    }
+  }
+}
+function buildUsageComparator({
+  ignoreEslintDisabledNodes,
+  sortingNodes,
+  options,
+}) {
+  let orderByNode = buildOrderByNodeMap()
+  return (a, b) => {
+    let nodeA = a.node
+    let nodeB = b.node
+    let orderA = orderByNode.get(nodeA)
+    let orderB = orderByNode.get(nodeB)
+    return computeOrderedValue(orderA - orderB, options.order)
+  }
+  function buildOrderByNodeMap() {
+    let sortingNodesWithUpdatedDependencies = sortingNodes.map(
+      ({ isEslintDisabled, dependencyNames, node }) => ({
+        dependencies: computeDependencies(node, { type: 'soft' }),
+        isEslintDisabled,
+        dependencyNames,
+        node,
+      }),
+    )
+    let sortedSortingNodes = sortNodesByDependencies(
+      sortingNodesWithUpdatedDependencies,
+      { ignoreEslintDisabledNodes },
+    )
+    let orderByNodeMap = /* @__PURE__ */ new Map()
+    for (let [i, { node }] of sortedSortingNodes.entries()) {
+      orderByNodeMap.set(node, i)
+    }
+    return orderByNodeMap
+  }
+}
+export { buildComparatorByOptionsComputer }

package/dist/rules/sort-modules/compute-dependencies.d.ts

@@ -0,0 +1,27 @@
+import { TSESTree } from '@typescript-eslint/types'
+interface HardDependencyDetection {
+  searchStaticMethodsAndFunctionProperties: boolean
+  type: 'hard'
+}
+interface SoftDependencyDetection {
+  searchStaticMethodsAndFunctionProperties?: never
+  type: 'soft'
+}
+type DependencyDetection = HardDependencyDetection | SoftDependencyDetection
+/**
+ * Computes the dependencies of a given AST node.
+ *
+ * @param node - The AST node to analyze.
+ * @param dependencyDetection - The dependency detection strategy. Hard
+ *   dependencies consider dependencies impacting compilation, while soft
+ *   dependencies also consider type references.
+ * @returns The names of the dependencies.
+ */
+export declare function computeDependencies(
+  node:
+    | TSESTree.ClassDeclaration
+    | TSESTree.ProgramStatement
+    | TSESTree.TSEnumMember,
+  dependencyDetection: DependencyDetection,
+): string[]
+export {}