eslint-plugin-perfectionist 5.2.0 → 5.3.0

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

@@ -1,11 +1,6 @@
 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'
+import { RegexOption, TypeOption } from '../../types/common-options.js'
+import { AllCommonOptions } from '../../types/all-common-options.js'
 /**
  * Configuration options for the sort-jsx-props rule.
  *
@@ -30,13 +25,14 @@ export type Options = Partial<
        */
       tagMatchesPattern?: RegexOption
     }
-  } & CommonGroupsOptions<
-    SingleCustomGroup,
-    Record<string, never>,
-    TypeOption
-  > &
-    Pick<CommonPartitionOptions, 'partitionByNewLine'> &
-    CommonOptions<TypeOption>
+  } & Omit<
+    AllCommonOptions<
+      TypeOption,
+      AdditionalSortOptions,
+      CustomGroupMatchOptions
+    >,
+    'partitionByComment'
+  >
 >[]
 /**
  * Union type of all available JSX prop modifiers. Used to identify specific
@@ -57,7 +53,7 @@ export type Selector = (typeof allSelectors)[number]
  *     "modifiers": ["shorthand"]
  *   }
  */
-interface SingleCustomGroup {
+interface CustomGroupMatchOptions {
   /**
    * Regular expression pattern to match prop values. Props with values
    * matching this pattern will be included in this custom group.
@@ -75,6 +71,7 @@ interface SingleCustomGroup {
    */
   selector?: Selector
 }
+type AdditionalSortOptions = object
 /**
  * Complete list of available JSX prop selectors. Used for validation and JSON
  * schema generation.
@@ -86,8 +83,11 @@ export declare let allSelectors: readonly ['prop']
  */
 export declare let allModifiers: readonly ['shorthand', 'multiline']
 /**
- * JSON schema definition for validating single custom group configurations.
- * Used by ESLint to validate rule options at configuration time.
+ * Additional custom group match options JSON schema. Used by ESLint to validate
+ * rule options at configuration time.
  */
-export declare let singleCustomGroupJsonSchema: Record<string, JSONSchema4>
+export declare let additionalCustomGroupMatchOptionsJsonSchema: Record<
+  string,
+  JSONSchema4
+>
 export {}

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

@@ -5,9 +5,13 @@ import {
 import { buildRegexJsonSchema } from '../../utils/json-schemas/common-json-schemas.js'
 let allSelectors = ['prop']
 let allModifiers = ['shorthand', 'multiline']
-let singleCustomGroupJsonSchema = {
+let additionalCustomGroupMatchOptionsJsonSchema = {
   modifiers: buildCustomGroupModifiersJsonSchema(allModifiers),
   selector: buildCustomGroupSelectorJsonSchema(allSelectors),
   elementValuePattern: buildRegexJsonSchema(),
 }
-export { allModifiers, allSelectors, singleCustomGroupJsonSchema }
+export {
+  additionalCustomGroupMatchOptionsJsonSchema,
+  allModifiers,
+  allSelectors,
+}

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

@@ -10,14 +10,14 @@ import {
   EXTRA_SPACING_ERROR,
   MISSED_SPACING_ERROR,
 } from '../utils/report-errors.js'
-import { validateNewlinesAndPartitionConfiguration } from '../utils/validate-newlines-and-partition-configuration.js'
-import { buildDefaultOptionsByGroupIndexComputer } from '../utils/build-default-options-by-group-index-computer.js'
-import { defaultComparatorByOptionsComputer } from '../utils/compare/default-comparator-by-options-computer.js'
 import {
-  singleCustomGroupJsonSchema,
+  additionalCustomGroupMatchOptionsJsonSchema,
   allSelectors,
   allModifiers,
 } from './sort-jsx-props/types.js'
+import { validateNewlinesAndPartitionConfiguration } from '../utils/validate-newlines-and-partition-configuration.js'
+import { buildDefaultOptionsByGroupIndexComputer } from '../utils/build-default-options-by-group-index-computer.js'
+import { defaultComparatorByOptionsComputer } from '../utils/compare/default-comparator-by-options-computer.js'
 import { partitionByNewLineJsonSchema } from '../utils/json-schemas/common-partition-json-schemas.js'
 import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
 import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration.js'
@@ -131,10 +131,13 @@ const sortJsxProps = createEslintRule({
           let lastSortingNode = accumulator.at(-1)?.at(-1)
           if (
             shouldPartition({
+              options: {
+                partitionByNewLine: options.partitionByNewLine,
+                partitionByComment: false,
+              },
               lastSortingNode,
               sortingNode,
               sourceCode,
-              options,
             })
           ) {
             accumulator.push([])
@@ -169,8 +172,11 @@ const sortJsxProps = createEslintRule({
           },
           sortNodesExcludingEslintDisabled:
             createSortNodesExcludingEslintDisabled(currentNodes),
+          options: {
+            ...options,
+            partitionByComment: false,
+          },
           nodes: currentNodes,
-          options,
           context,
         })
       }
@@ -182,7 +188,8 @@ const sortJsxProps = createEslintRule({
         properties: {
           ...buildCommonJsonSchemas(),
           ...buildCommonGroupsJsonSchemas({
-            singleCustomGroupJsonSchema,
+            additionalCustomGroupMatchProperties:
+              additionalCustomGroupMatchOptionsJsonSchema,
           }),
           useConfigurationIf: buildUseConfigurationIfJsonSchema({
             additionalProperties: {

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

@@ -1,10 +1,5 @@
-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'
+import { RegexOption, TypeOption } from '../../types/common-options.js'
+import { AllCommonOptions } from '../../types/all-common-options.js'
 /**
  * Configuration options for the sort-maps rule.
  *
@@ -24,14 +19,13 @@ export type Options = Partial<
        */
       allNamesMatchPattern?: RegexOption
     }
-  } & CommonGroupsOptions<
-    SingleCustomGroup,
-    Record<string, never>,
-    TypeOption
-  > &
-    CommonOptions<TypeOption> &
-    CommonPartitionOptions
+  } & AllCommonOptions<
+    TypeOption,
+    AdditionalSortOptions,
+    CustomGroupMatchOptions
+  >
 >[]
-/** Additional configuration for a single custom group. */
-type SingleCustomGroup = Record<string, never>
+/** Match options for a custom group. */
+type CustomGroupMatchOptions = object
+type AdditionalSortOptions = object
 export {}

package/dist/rules/sort-maps.js

@@ -1,3 +1,4 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
 import {
   partitionByNewLineJsonSchema,
   partitionByCommentJsonSchema,
@@ -54,10 +55,10 @@ const sortMaps = createEslintRule({
   create: context => ({
     NewExpression: node => {
       if (
-        node.callee.type !== 'Identifier' ||
+        node.callee.type !== AST_NODE_TYPES.Identifier ||
         node.callee.name !== 'Map' ||
         node.arguments.length === 0 ||
-        node.arguments[0]?.type !== 'ArrayExpression'
+        node.arguments[0]?.type !== AST_NODE_TYPES.ArrayExpression
       ) {
         return
       }
@@ -70,7 +71,8 @@ const sortMaps = createEslintRule({
       let matchedContextOptions = filterOptionsByAllNamesMatch({
         nodeNames: elements
           .filter(
-            element => element !== null && element.type !== 'SpreadElement',
+            element =>
+              element !== null && element.type !== AST_NODE_TYPES.SpreadElement,
           )
           .map(element => getNodeName({ sourceCode, element })),
         contextOptions: context.options,
@@ -88,7 +90,10 @@ const sortMaps = createEslintRule({
       })
       let parts = elements.reduce(
         (accumulator, element) => {
-          if (element === null || element.type === 'SpreadElement') {
+          if (
+            element === null ||
+            element.type === AST_NODE_TYPES.SpreadElement
+          ) {
             accumulator.push([])
           } else {
             accumulator.at(-1).push(element)
@@ -205,11 +210,11 @@ const sortMaps = createEslintRule({
   name: 'sort-maps',
 })
 function getNodeName({ sourceCode, element }) {
-  if (element.type === 'ArrayExpression') {
+  if (element.type === AST_NODE_TYPES.ArrayExpression) {
     let [left] = element.elements
     if (!left) {
       return `${left}`
-    } else if (left.type === 'Literal') {
+    } else if (left.type === AST_NODE_TYPES.Literal) {
       return left.raw
     }
     return sourceCode.getText(left)

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

@@ -9,6 +9,8 @@ function buildComparatorByOptionsComputer({
 }) {
   return options => {
     switch (options.type) {
+      /* v8 ignore next -- @preserve Untested for now as not a relevant sort for this rule. */
+      case 'subgroup-order':
       case 'alphabetical':
       case 'line-length':
       case 'unsorted':

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

@@ -1,4 +1,4 @@
-import { TSESTree } from '@typescript-eslint/types'
+import { SortModulesNode } from './types.js'
 interface HardDependencyDetection {
   searchStaticMethodsAndFunctionProperties: boolean
   type: 'hard'
@@ -18,10 +18,7 @@ type DependencyDetection = HardDependencyDetection | SoftDependencyDetection
  * @returns The names of the dependencies.
  */
 export declare function computeDependencies(
-  node:
-    | TSESTree.ClassDeclaration
-    | TSESTree.ProgramStatement
-    | TSESTree.TSEnumMember,
+  node: SortModulesNode,
   dependencyDetection: DependencyDetection,
 ): string[]
 export {}

package/dist/rules/sort-modules/compute-dependencies.js

@@ -89,6 +89,9 @@ function computeDependencies(node, dependencyDetection) {
       if ('properties' in nodeToCheck) {
         traverseNode(nodeToCheck.properties)
       }
+      if ('property' in nodeToCheck) {
+        checkNode(nodeToCheck.property)
+      }
       if ('right' in nodeToCheck) {
         checkNode(nodeToCheck.right)
       }

package/dist/rules/sort-modules/compute-node-details.d.ts

@@ -0,0 +1,38 @@
+import { TSESTree } from '@typescript-eslint/types'
+import { TSESLint } from '@typescript-eslint/utils'
+import { SortModulesNode, Modifier, Selector } from './types.js'
+interface ParsableNodeDetails {
+  nodeDetails: {
+    addSafetySemicolonWhenInline: boolean
+    dependencies: string[]
+    modifiers: Modifier[]
+    decorators: string[]
+    selector: Selector
+    name: string
+  }
+  shouldPartitionAfterNode?: never
+  moduleBlock?: never
+}
+interface NonParsableNodeDetails {
+  moduleBlock: TSESTree.TSModuleBlock | null
+  shouldPartitionAfterNode: boolean
+  nodeDetails?: never
+}
+type Details = NonParsableNodeDetails | ParsableNodeDetails
+/**
+ * Compute details about a module-related node.
+ *
+ * @param params - The parameters object.
+ * @param params.sourceCode - The source code object.
+ * @param params.node - The AST node to compute details for.
+ * @returns The computed details about the node, such as whether it should be
+ *   ignored, if a module block was found, and information about the node.
+ */
+export declare function computeNodeDetails({
+  sourceCode,
+  node,
+}: {
+  sourceCode: TSESLint.SourceCode
+  node: SortModulesNode
+}): Details
+export {}

package/dist/rules/sort-modules/compute-node-details.js

@@ -0,0 +1,127 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import { isPropertyOrAccessorNode } from './is-property-or-accessor-node.js'
+import { getNodeDecorators } from '../../utils/get-node-decorators.js'
+import { getDecoratorName } from '../../utils/get-decorator-name.js'
+import { isArrowFunctionNode } from './is-arrow-function-node.js'
+import { computeDependencies } from './compute-dependencies.js'
+function computeNodeDetails({ sourceCode, node }) {
+  let selector
+  let name
+  let modifiers = []
+  let dependencies = []
+  let decorators = []
+  let addSafetySemicolonWhenInline = false
+  let moduleBlock = null
+  let shouldPartitionAfterNode = false
+  let ignoredDueToDecoratorBeforeExportClass = false
+  let exportNode
+  parseNode(node)
+  if (!selector || !name || ignoredDueToDecoratorBeforeExportClass) {
+    return {
+      shouldPartitionAfterNode,
+      moduleBlock,
+    }
+  }
+  return {
+    nodeDetails: {
+      addSafetySemicolonWhenInline,
+      dependencies,
+      decorators,
+      modifiers,
+      selector,
+      name,
+    },
+  }
+  function parseNode(nodeToParse) {
+    if ('declare' in nodeToParse && nodeToParse.declare) {
+      modifiers.push('declare')
+    }
+    switch (nodeToParse.type) {
+      case AST_NODE_TYPES.ExportDefaultDeclaration:
+        exportNode = nodeToParse
+        modifiers.push('default', 'export')
+        parseNode(nodeToParse.declaration)
+        break
+      case AST_NODE_TYPES.ExportNamedDeclaration:
+        exportNode = nodeToParse
+        if (nodeToParse.declaration) {
+          parseNode(nodeToParse.declaration)
+        }
+        modifiers.push('export')
+        break
+      case AST_NODE_TYPES.TSInterfaceDeclaration:
+        selector = 'interface'
+        ;({ name } = nodeToParse.id)
+        break
+      case AST_NODE_TYPES.TSTypeAliasDeclaration:
+        selector = 'type'
+        ;({ name } = nodeToParse.id)
+        addSafetySemicolonWhenInline = true
+        break
+      case AST_NODE_TYPES.FunctionDeclaration:
+      case AST_NODE_TYPES.TSDeclareFunction:
+        selector = 'function'
+        if (nodeToParse.async) {
+          modifiers.push('async')
+        }
+        if (modifiers.includes('declare')) {
+          addSafetySemicolonWhenInline = true
+        }
+        name = nodeToParse.id?.name
+        break
+      case AST_NODE_TYPES.TSModuleDeclaration:
+        shouldPartitionAfterNode = true
+        moduleBlock = nodeToParse.body ?? null
+        break
+      case AST_NODE_TYPES.VariableDeclaration:
+        shouldPartitionAfterNode = true
+        break
+      case AST_NODE_TYPES.TSEnumDeclaration:
+        selector = 'enum'
+        ;({ name } = nodeToParse.id)
+        dependencies = [...dependencies, ...extractDependencies(nodeToParse)]
+        break
+      case AST_NODE_TYPES.ClassDeclaration:
+        selector = 'class'
+        name = nodeToParse.id?.name
+        let nodeDecorators = getNodeDecorators(nodeToParse)
+        if (nodeDecorators[0]) {
+          modifiers.push('decorated')
+          ignoredDueToDecoratorBeforeExportClass = isExportAfterDecorators({
+            firstDecorator: nodeDecorators[0],
+            exportNode,
+          })
+        }
+        decorators = nodeDecorators.map(decorator =>
+          getDecoratorName({
+            sourceCode,
+            decorator,
+          }),
+        )
+        dependencies = [...dependencies, ...extractDependencies(nodeToParse)]
+        break
+    }
+  }
+}
+function extractDependencies(expression) {
+  let searchStaticMethodsAndFunctionProperties =
+    expression.type === AST_NODE_TYPES.ClassDeclaration &&
+    expression.body.body.some(
+      classElement =>
+        classElement.type === AST_NODE_TYPES.StaticBlock ||
+        (classElement.static &&
+          isPropertyOrAccessorNode(classElement) &&
+          !isArrowFunctionNode(classElement)),
+    )
+  return computeDependencies(expression, {
+    searchStaticMethodsAndFunctionProperties,
+    type: 'hard',
+  })
+}
+function isExportAfterDecorators({ firstDecorator, exportNode }) {
+  if (!exportNode) {
+    return false
+  }
+  return exportNode.range[0] > firstDecorator.range[0]
+}
+export { computeNodeDetails }

package/dist/rules/sort-modules/is-arrow-function-node.js

@@ -1,4 +1,4 @@
-import { AST_NODE_TYPES } from '@typescript-eslint/types'
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
 import { isPropertyOrAccessorNode } from './is-property-or-accessor-node.js'
 function isArrowFunctionNode(node) {
   return (

package/dist/rules/sort-modules/is-property-or-accessor-node.js

@@ -1,4 +1,4 @@
-import { AST_NODE_TYPES } from '@typescript-eslint/types'
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
 function isPropertyOrAccessorNode(node) {
   return (
     node.type === AST_NODE_TYPES.PropertyDefinition ||

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

@@ -1,13 +1,18 @@
 import { JSONSchema4 } from '@typescript-eslint/utils/json-schema'
 import { TSESTree } from '@typescript-eslint/types'
-import {
-  CommonOptions,
-  RegexOption,
-  TypeOption,
-} from '../../types/common-options.js'
 import { SortingNodeWithDependencies } from '../../utils/sort-nodes-by-dependencies.js'
-import { CommonPartitionOptions } from '../../types/common-partition-options.js'
-import { CommonGroupsOptions } from '../../types/common-groups-options.js'
+import { RegexOption, TypeOption } from '../../types/common-options.js'
+import { AllCommonOptions } from '../../types/all-common-options.js'
+export type SortModulesNode =
+  | TSESTree.ExportDefaultDeclaration
+  | TSESTree.ExportNamedDeclaration
+  | TSESTree.TSInterfaceDeclaration
+  | TSESTree.TSTypeAliasDeclaration
+  | TSESTree.FunctionDeclaration
+  | TSESTree.TSModuleDeclaration
+  | TSESTree.TSDeclareFunction
+  | TSESTree.TSEnumDeclaration
+  | TSESTree.ClassDeclaration
 /**
  * Configuration options for the sort-modules rule.
  *
@@ -16,18 +21,16 @@ import { CommonGroupsOptions } from '../../types/common-groups-options.js'
  */
 export type SortModulesOptions = [
   Partial<
-    CommonGroupsOptions<
-      SingleCustomGroup,
-      Record<string, never>,
-      CustomTypeOption
-    > &
-      CommonOptions<CustomTypeOption> &
-      CommonPartitionOptions
+    AllCommonOptions<
+      CustomTypeOption,
+      AdditionalSortOptions,
+      CustomGroupMatchOptions
+    >
   >,
 ]
 /** Represents a sorting node for a module statement. */
 export type SortModulesSortingNode =
-  SortingNodeWithDependencies<TSESTree.ProgramStatement>
+  SortingNodeWithDependencies<SortModulesNode>
 /**
  * Union type of all available module member selectors. Used to categorize
  * different types of module-level declarations.
@@ -44,7 +47,7 @@ export type Modifier = (typeof allModifiers)[number]
  * Custom groups allow fine-grained control over how module members are grouped
  * and sorted based on their types, modifiers, and patterns.
  */
-interface SingleCustomGroup {
+interface CustomGroupMatchOptions {
   /**
    * Regular expression pattern to match decorator names. Members with
    * decorators matching this pattern will be included in this custom group.
@@ -56,6 +59,7 @@ interface SingleCustomGroup {
   selector?: Selector
 }
 type CustomTypeOption = typeof USAGE_TYPE_OPTION | TypeOption
+type AdditionalSortOptions = object
 /**
  * Complete list of available module member selectors. Used for validation and
  * JSON schema generation.
@@ -82,6 +86,9 @@ export declare let allModifiers: readonly [
  * Ideally, we should generate as many schemas as there are selectors, and
  * ensure that users do not enter invalid modifiers for a given selector.
  */
-export declare let singleCustomGroupJsonSchema: Record<string, JSONSchema4>
+export declare let additionalCustomGroupMatchOptionsJsonSchema: Record<
+  string,
+  JSONSchema4
+>
 export declare const USAGE_TYPE_OPTION = 'usage'
 export {}

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

@@ -13,7 +13,7 @@ let allSelectors = [
   'class',
 ]
 let allModifiers = ['async', 'declare', 'decorated', 'default', 'export']
-let singleCustomGroupJsonSchema = {
+let additionalCustomGroupMatchOptionsJsonSchema = {
   modifiers: buildCustomGroupModifiersJsonSchema(allModifiers),
   selector: buildCustomGroupSelectorJsonSchema(allSelectors),
   decoratorNamePattern: buildRegexJsonSchema(),
@@ -21,7 +21,7 @@ let singleCustomGroupJsonSchema = {
 const USAGE_TYPE_OPTION = 'usage'
 export {
   USAGE_TYPE_OPTION,
+  additionalCustomGroupMatchOptionsJsonSchema,
   allModifiers,
   allSelectors,
-  singleCustomGroupJsonSchema,
 }