eslint-plugin-perfectionist 5.2.0 → 5.3.1

package/dist/rules/sort-classes/node-info/compute-method-details.js

@@ -0,0 +1,80 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import {
+  computeStaticModifier,
+  computeAbstractModifier,
+  computeDecoratedModifier,
+  computeOverrideModifier,
+  computeAccessibilityModifier,
+  computeOptionalModifier,
+  computeAsyncModifier,
+} from './common-modifiers.js'
+import { computeMethodOrPropertyNameDetails } from './compute-method-or-property-name-details.js'
+import { UnreachableCaseError } from '../../../utils/unreachable-case-error.js'
+function computeMethodDetails({
+  hasParentDeclare,
+  isDecorated,
+  sourceCode,
+  method,
+}) {
+  let { hasPrivateHash, name } = computeMethodOrPropertyNameDetails(
+    method,
+    sourceCode,
+  )
+  return {
+    addSafetySemicolonWhenInline: shouldAddSafetySemicolonWhenInline({
+      hasParentDeclare,
+      method,
+    }),
+    modifiers: computeModifiers({
+      hasPrivateHash,
+      isDecorated,
+      method,
+    }),
+    selectors: computeSelectors(method),
+    name,
+  }
+}
+function computeSelectors(method) {
+  return [...computeSetterOrConstructorSelector(), 'method']
+  function computeSetterOrConstructorSelector() {
+    switch (method.kind) {
+      case 'constructor':
+        return ['constructor']
+      case 'method':
+        return []
+      case 'set':
+        return ['set-method']
+      case 'get':
+        return ['get-method']
+      /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+      default:
+        throw new UnreachableCaseError(method.kind)
+    }
+  }
+}
+function computeModifiers({ hasPrivateHash, isDecorated, method }) {
+  return [
+    ...computeStaticModifier(method),
+    ...computeAbstractModifier(method),
+    ...computeDecoratedModifier(isDecorated),
+    ...computeOverrideModifier(method),
+    ...computeAccessibilityModifier({
+      hasPrivateHash,
+      node: method,
+    }),
+    ...computeOptionalModifier(method),
+    ...computeAsyncModifier(method.value),
+  ]
+}
+function shouldAddSafetySemicolonWhenInline({ hasParentDeclare, method }) {
+  switch (method.type) {
+    case AST_NODE_TYPES.TSAbstractMethodDefinition:
+      return true
+    case AST_NODE_TYPES.MethodDefinition:
+      return hasParentDeclare
+    /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+    default:
+      throw new UnreachableCaseError(method)
+  }
+}
+export { computeMethodDetails }

package/dist/rules/sort-classes/node-info/compute-method-or-property-name-details.d.ts

@@ -0,0 +1,21 @@
+import { TSESTree } from '@typescript-eslint/types'
+import { TSESLint } from '@typescript-eslint/utils'
+import { NodeNameDetails } from '../compute-identifier-name-details.js'
+/**
+ * Computes the name details of a method or property node.
+ *
+ * @param node - The method or property node to compute the name for.
+ * @param sourceCode - The ESLint source code object.
+ * @returns An object containing the name, whether it has a private hash, and
+ *   the name without the starting hash.
+ */
+export declare function computeMethodOrPropertyNameDetails(
+  node:
+    | TSESTree.TSAbstractPropertyDefinition
+    | TSESTree.TSAbstractMethodDefinition
+    | TSESTree.TSAbstractAccessorProperty
+    | TSESTree.PropertyDefinition
+    | TSESTree.MethodDefinition
+    | TSESTree.AccessorProperty,
+  sourceCode: TSESLint.SourceCode,
+): NodeNameDetails

package/dist/rules/sort-classes/node-info/compute-method-or-property-name-details.js

@@ -0,0 +1,17 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import { computeIdentifierNameDetails } from '../compute-identifier-name-details.js'
+function computeMethodOrPropertyNameDetails(node, sourceCode) {
+  switch (node.key.type) {
+    case AST_NODE_TYPES.PrivateIdentifier:
+    case AST_NODE_TYPES.Identifier:
+    case AST_NODE_TYPES.Literal:
+      return computeIdentifierNameDetails(node.key)
+    default:
+      return {
+        nameWithoutStartingHash: sourceCode.getText(node.key),
+        name: sourceCode.getText(node.key),
+        hasPrivateHash: false,
+      }
+  }
+}
+export { computeMethodOrPropertyNameDetails }

package/dist/rules/sort-classes/node-info/compute-property-details.d.ts

@@ -0,0 +1,36 @@
+import { TSESTree } from '@typescript-eslint/types'
+import { TSESLint } from '@typescript-eslint/utils'
+import { RegexOption } from '../../../types/common-options.js'
+import { Modifier, Selector } from '../types.js'
+/**
+ * Computes details related to a property.
+ *
+ * @param params - Parameters object.
+ * @param params.isDecorated - Whether the accessor is decorated.
+ * @param params.property - The property node to compute information for.
+ * @param params.ignoreCallbackDependenciesPatterns - Patterns to ignore when
+ *   computing dependencies.
+ * @param params.sourceCode - The source code object.
+ * @param params.className - The name of the class containing the property.
+ * @returns An object containing various details about the property.
+ */
+export declare function computePropertyDetails({
+  ignoreCallbackDependenciesPatterns,
+  isDecorated,
+  sourceCode,
+  className,
+  property,
+}: {
+  property: TSESTree.TSAbstractPropertyDefinition | TSESTree.PropertyDefinition
+  ignoreCallbackDependenciesPatterns: RegexOption
+  sourceCode: TSESLint.SourceCode
+  className: undefined | string
+  isDecorated: boolean
+}): {
+  memberValue: undefined | string
+  dependencyNames: string[]
+  dependencies: string[]
+  modifiers: Modifier[]
+  selectors: Selector[]
+  name: string
+}

package/dist/rules/sort-classes/node-info/compute-property-details.js

@@ -0,0 +1,109 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import {
+  computeStaticModifier,
+  computeAbstractModifier,
+  computeDecoratedModifier,
+  computeOverrideModifier,
+  computeReadonlyModifier,
+  computeAccessibilityModifier,
+  computeOptionalModifier,
+  computeAsyncModifier,
+} from './common-modifiers.js'
+import { computeMethodOrPropertyNameDetails } from './compute-method-or-property-name-details.js'
+import { computeDependencyName } from '../compute-dependency-name.js'
+import { computeDependencies } from '../compute-dependencies.js'
+function computePropertyDetails({
+  ignoreCallbackDependenciesPatterns,
+  isDecorated,
+  sourceCode,
+  className,
+  property,
+}) {
+  let { nameWithoutStartingHash, hasPrivateHash, name } =
+    computeMethodOrPropertyNameDetails(property, sourceCode)
+  let modifiers = computeModifiers({
+    hasPrivateHash,
+    isDecorated,
+    property,
+  })
+  return {
+    dependencyNames: [
+      computeDependencyName({
+        nodeNameWithoutStartingHash: nameWithoutStartingHash,
+        isStatic: modifiers.includes('static'),
+        hasPrivateHash,
+      }),
+    ],
+    memberValue:
+      !isFunctionExpression(property.value) && property.value
+        ? sourceCode.getText(property.value)
+        : void 0,
+    dependencies: computePropertyDependencies({
+      ignoreCallbackDependenciesPatterns,
+      className,
+      property,
+    }),
+    selectors: computeSelectors(property),
+    modifiers,
+    name,
+  }
+}
+function computeModifiers({ hasPrivateHash, isDecorated, property }) {
+  return [
+    ...computeStaticModifier(property),
+    ...computeDeclareModifier(),
+    ...computeAbstractModifier(property),
+    ...computeDecoratedModifier(isDecorated),
+    ...computeOverrideModifier(property),
+    ...computeReadonlyModifier(property),
+    ...computeAccessibilityModifier({
+      hasPrivateHash,
+      node: property,
+    }),
+    ...computeOptionalModifier(property),
+    ...computeAsyncModifierIfFunctionProperty(),
+  ]
+  function computeDeclareModifier() {
+    return property.declare ? ['declare'] : []
+  }
+  function computeAsyncModifierIfFunctionProperty() {
+    if (!isFunctionExpression(property.value)) {
+      return []
+    }
+    return computeAsyncModifier(property.value)
+  }
+}
+function computePropertyDependencies({
+  ignoreCallbackDependenciesPatterns,
+  className,
+  property,
+}) {
+  if (isFunctionExpression(property.value)) {
+    return []
+  }
+  if (!property.value) {
+    return []
+  }
+  return computeDependencies({
+    ignoreCallbackDependenciesPatterns,
+    isMemberStatic: property.static,
+    expression: property.value,
+    className,
+  })
+}
+function computeSelectors(property) {
+  return [...computeFunctionPropertySelector(), 'property']
+  function computeFunctionPropertySelector() {
+    return isFunctionExpression(property.value) ? ['function-property'] : []
+  }
+}
+function isFunctionExpression(node) {
+  if (!node) {
+    return false
+  }
+  return (
+    node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+    node.type === AST_NODE_TYPES.FunctionExpression
+  )
+}
+export { computePropertyDetails }

package/dist/rules/sort-classes/node-info/compute-static-block-details.d.ts

@@ -0,0 +1,26 @@
+import { TSESTree } from '@typescript-eslint/types'
+import { RegexOption } from '../../../types/common-options.js'
+import { Modifier, Selector } from '../types.js'
+/**
+ * Computes details related to a static block.
+ *
+ * @param params - Parameters object.
+ * @param params.staticBlock - The static block node to compute information for.
+ * @param params.ignoreCallbackDependenciesPatterns - Patterns to ignore when
+ *   computing dependencies.
+ * @param params.className - The name of the class containing the property.
+ * @returns An object containing various details about the static block.
+ */
+export declare function computeStaticBlockDetails({
+  ignoreCallbackDependenciesPatterns,
+  staticBlock,
+  className,
+}: {
+  ignoreCallbackDependenciesPatterns: RegexOption
+  staticBlock: TSESTree.StaticBlock
+  className: undefined | string
+}): {
+  dependencies: string[]
+  selectors: Selector[]
+  modifiers: Modifier[]
+}

package/dist/rules/sort-classes/node-info/compute-static-block-details.js

@@ -0,0 +1,18 @@
+import { computeDependencies } from '../compute-dependencies.js'
+function computeStaticBlockDetails({
+  ignoreCallbackDependenciesPatterns,
+  staticBlock,
+  className,
+}) {
+  return {
+    dependencies: computeDependencies({
+      ignoreCallbackDependenciesPatterns,
+      expression: staticBlock,
+      isMemberStatic: true,
+      className,
+    }),
+    selectors: ['static-block'],
+    modifiers: [],
+  }
+}
+export { computeStaticBlockDetails }

package/dist/rules/sort-classes/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-classes rule.
  *
@@ -21,13 +16,11 @@ export type SortClassesOptions = [
        * inside these callbacks won't influence the ordering.
        */
       ignoreCallbackDependenciesPatterns: RegexOption
-    } & CommonGroupsOptions<
-      SingleCustomGroup,
-      Record<string, never>,
-      TypeOption
-    > &
-      CommonOptions<TypeOption> &
-      CommonPartitionOptions
+    } & AllCommonOptions<
+      TypeOption,
+      AdditionalSortOptions,
+      CustomGroupMatchOptions
+    >
   >,
 ]
 /**
@@ -47,7 +40,7 @@ export type Modifier = (typeof allModifiers)[number]
  * property, etc.) and various patterns matching their names, values, or
  * decorators.
  */
-interface SingleCustomGroup {
+interface CustomGroupMatchOptions {
   /** Pattern to match decorator names (e.g., '@Component'). */
   decoratorNamePattern?: RegexOption
   /**
@@ -60,6 +53,7 @@ interface SingleCustomGroup {
   /** The type of class member this group applies to. */
   selector?: Selector
 }
+type AdditionalSortOptions = object
 /**
  * Complete list of available class member selectors. Used for validation and
  * JSON schema generation.
@@ -93,11 +87,14 @@ export declare let allModifiers: readonly [
   'optional',
 ]
 /**
- * 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.
  *
  * Note: 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 {}

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

@@ -27,10 +27,14 @@ let allModifiers = [
   'declare',
   'optional',
 ]
-let singleCustomGroupJsonSchema = {
+let additionalCustomGroupMatchOptionsJsonSchema = {
   modifiers: buildCustomGroupModifiersJsonSchema(allModifiers),
   selector: buildCustomGroupSelectorJsonSchema(allSelectors),
   decoratorNamePattern: buildRegexJsonSchema(),
   elementValuePattern: buildRegexJsonSchema(),
 }
-export { allModifiers, allSelectors, singleCustomGroupJsonSchema }
+export {
+  additionalCustomGroupMatchOptionsJsonSchema,
+  allModifiers,
+  allSelectors,
+}