eslint-plugin-perfectionist 5.5.0 → 5.7.0

package/dist/package.json.js

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

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

@@ -0,0 +1,11 @@
+import { TSESTree } from '@typescript-eslint/types'
+/**
+ * Computes array elements for the given expression.
+ *
+ * @param expression - The expression to compute array elements from.
+ * @returns An array of elements if the expression is an array or a new
+ *   expression, otherwise null.
+ */
+export declare function computeArrayElements(
+  expression: TSESTree.ArrayExpression | TSESTree.NewExpression,
+): (TSESTree.SpreadElement | TSESTree.Expression | null)[] | null

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

@@ -0,0 +1,20 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import { UnreachableCaseError } from '../../utils/unreachable-case-error.js'
+function computeArrayElements(expression) {
+  switch (expression.type) {
+    case AST_NODE_TYPES.ArrayExpression:
+      return expression.elements
+    case AST_NODE_TYPES.NewExpression:
+      if (expression.callee.type !== AST_NODE_TYPES.Identifier) {
+        return null
+      }
+      if (expression.callee.name !== 'Array') {
+        return null
+      }
+      return expression.arguments
+    /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+    default:
+      throw new UnreachableCaseError(expression)
+  }
+}
+export { computeArrayElements }

package/dist/rules/sort-array-includes/compute-matched-context-options.d.ts

@@ -0,0 +1,25 @@
+import { RuleContext } from '@typescript-eslint/utils/ts-eslint'
+import { TSESTree } from '@typescript-eslint/types'
+import { Options } from './types.js'
+/**
+ * Computes the matched context options for a given array node.
+ *
+ * @param params - Parameters.
+ * @param params.matchedAstSelectors - The matched AST selectors for an array
+ *   node.
+ * @param params.elements - The array elements to compute the context options
+ *   for.
+ * @param params.context - The rule context.
+ * @returns The matched context options or undefined if none match.
+ */
+export declare function computeMatchedContextOptions<
+  MessageIds extends string,
+>({
+  matchedAstSelectors,
+  elements,
+  context,
+}: {
+  elements: (TSESTree.SpreadElement | TSESTree.Expression | null)[]
+  context: Readonly<RuleContext<MessageIds, Options>>
+  matchedAstSelectors: ReadonlySet<string>
+}): Options[number] | undefined

package/dist/rules/sort-array-includes/compute-matched-context-options.js

@@ -0,0 +1,33 @@
+import { passesAllNamesMatchPatternFilter } from '../../utils/context-matching/passes-all-names-match-pattern-filter.js'
+import { passesAstSelectorFilter } from '../../utils/context-matching/passes-ast-selector-filter.js'
+import { computeNodeName } from './compute-node-name.js'
+function computeMatchedContextOptions({
+  matchedAstSelectors,
+  elements,
+  context,
+}) {
+  let nodeNames = elements
+    .filter(element => element !== null)
+    .map(element =>
+      computeNodeName({ sourceCode: context.sourceCode, node: element }),
+    )
+  return context.options.find(options =>
+    isContextOptionMatching({ matchedAstSelectors, nodeNames, options }),
+  )
+}
+function isContextOptionMatching({ matchedAstSelectors, nodeNames, options }) {
+  if (!options.useConfigurationIf) {
+    return true
+  }
+  return (
+    passesAllNamesMatchPatternFilter({
+      allNamesMatchPattern: options.useConfigurationIf.allNamesMatchPattern,
+      nodeNames,
+    }) &&
+    passesAstSelectorFilter({
+      matchesAstSelector: options.useConfigurationIf.matchesAstSelector,
+      matchedAstSelectors,
+    })
+  )
+}
+export { computeMatchedContextOptions }

package/dist/rules/sort-array-includes/compute-node-name.d.ts

@@ -0,0 +1,17 @@
+import { TSESTree } from '@typescript-eslint/types'
+import { TSESLint } from '@typescript-eslint/utils'
+/**
+ * Computes the name of an array member.
+ *
+ * @param props - The parameters object.
+ * @param props.sourceCode - ESLint source code object for text extraction.
+ * @param props.node - The AST node representing an array member.
+ * @returns The name of the array member.
+ */
+export declare function computeNodeName({
+  sourceCode,
+  node,
+}: {
+  node: TSESTree.SpreadElement | TSESTree.Expression
+  sourceCode: TSESLint.SourceCode
+}): string

package/dist/rules/sort-array-includes/compute-node-name.js

@@ -0,0 +1,7 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+function computeNodeName({ sourceCode, node }) {
+  return node.type === AST_NODE_TYPES.Literal ?
+      `${node.value}`
+    : sourceCode.getText(node)
+}
+export { computeNodeName }

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

@@ -0,0 +1,23 @@
+import { RuleContext } from '@typescript-eslint/utils/ts-eslint'
+import { TSESTree } from '@typescript-eslint/types'
+import { Options } from './types.js'
+export declare function sortArray<MessageIds extends string>({
+  cachedGroupsByModifiersAndSelectors,
+  availableMessageIds,
+  matchedAstSelectors,
+  defaultOptions,
+  context,
+  node,
+}: {
+  availableMessageIds: {
+    missedSpacingBetweenMembers: MessageIds
+    extraSpacingBetweenMembers: MessageIds
+    unexpectedGroupOrder: MessageIds
+    unexpectedOrder: MessageIds
+  }
+  cachedGroupsByModifiersAndSelectors: Map<string, string[]>
+  node: TSESTree.ArrayExpression | TSESTree.NewExpression
+  context: Readonly<RuleContext<MessageIds, Options>>
+  defaultOptions: Required<Options[number]>
+  matchedAstSelectors: ReadonlySet<string>
+}): void

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

@@ -0,0 +1,131 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import { validateNewlinesAndPartitionConfiguration } from '../../utils/validate-newlines-and-partition-configuration.js'
+import { defaultComparatorByOptionsComputer } from '../../utils/compare/default-comparator-by-options-computer.js'
+import { buildOptionsByGroupIndexComputer } from '../../utils/build-options-by-group-index-computer.js'
+import { validateCustomSortConfiguration } from '../../utils/validate-custom-sort-configuration.js'
+import { validateGroupsConfiguration } from '../../utils/validate-groups-configuration.js'
+import { generatePredefinedGroups } from '../../utils/generate-predefined-groups.js'
+import { computeMatchedContextOptions } from './compute-matched-context-options.js'
+import { getEslintDisabledLines } from '../../utils/get-eslint-disabled-lines.js'
+import { doesCustomGroupMatch } from '../../utils/does-custom-group-match.js'
+import { isNodeEslintDisabled } from '../../utils/is-node-eslint-disabled.js'
+import { sortNodesByGroups } from '../../utils/sort-nodes-by-groups.js'
+import { computeArrayElements } from './compute-array-elements.js'
+import { reportAllErrors } from '../../utils/report-all-errors.js'
+import { shouldPartition } from '../../utils/should-partition.js'
+import { computeGroup } from '../../utils/compute-group.js'
+import { rangeToDiff } from '../../utils/range-to-diff.js'
+import { getSettings } from '../../utils/get-settings.js'
+import { computeNodeName } from './compute-node-name.js'
+import { isSortable } from '../../utils/is-sortable.js'
+import { complete } from '../../utils/complete.js'
+import { allSelectors } from './types.js'
+function sortArray({
+  cachedGroupsByModifiersAndSelectors,
+  availableMessageIds,
+  matchedAstSelectors,
+  defaultOptions,
+  context,
+  node,
+}) {
+  let elements = computeArrayElements(node)
+  if (!elements) {
+    return
+  }
+  if (!isSortable(elements)) {
+    return
+  }
+  let { sourceCode, id } = context
+  let settings = getSettings(context.settings)
+  let matchedContextOptions = computeMatchedContextOptions({
+    matchedAstSelectors,
+    elements,
+    context,
+  })
+  let options = complete(matchedContextOptions, settings, defaultOptions)
+  validateCustomSortConfiguration(options)
+  validateGroupsConfiguration({
+    selectors: allSelectors,
+    modifiers: [],
+    options,
+  })
+  validateNewlinesAndPartitionConfiguration(options)
+  let eslintDisabledLines = getEslintDisabledLines({
+    ruleName: id,
+    sourceCode,
+  })
+  let optionsByGroupIndexComputer = buildOptionsByGroupIndexComputer(options)
+  let formattedMembers = elements.reduce(
+    (accumulator, element) => {
+      if (element === null) {
+        return accumulator
+      }
+      if (element.type === AST_NODE_TYPES.SpreadElement) {
+        accumulator.push([])
+        return accumulator
+      }
+      let name = computeNodeName({ node: element, sourceCode })
+      let selector = 'literal'
+      let predefinedGroups = generatePredefinedGroups({
+        cache: cachedGroupsByModifiersAndSelectors,
+        selectors: [selector],
+        modifiers: [],
+      })
+      let group = computeGroup({
+        customGroupMatcher: customGroup =>
+          doesCustomGroupMatch({
+            selectors: [selector],
+            elementName: name,
+            modifiers: [],
+            customGroup,
+          }),
+        predefinedGroups,
+        options,
+      })
+      let sortingNode = {
+        isEslintDisabled: isNodeEslintDisabled(element, eslintDisabledLines),
+        size: rangeToDiff(element, sourceCode),
+        node: element,
+        group,
+        name,
+      }
+      let lastSortingNode = accumulator.at(-1)?.at(-1)
+      if (
+        shouldPartition({
+          lastSortingNode,
+          sortingNode,
+          sourceCode,
+          options,
+        })
+      ) {
+        accumulator.push([])
+      }
+      accumulator.at(-1).push({
+        ...sortingNode,
+        partitionId: accumulator.length,
+      })
+      return accumulator
+    },
+    [[]],
+  )
+  function sortNodesExcludingEslintDisabled(ignoreEslintDisabledNodes) {
+    return formattedMembers.flatMap(nodes2 =>
+      sortNodesByGroups({
+        comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
+        optionsByGroupIndexComputer,
+        ignoreEslintDisabledNodes,
+        groups: options.groups,
+        nodes: nodes2,
+      }),
+    )
+  }
+  let nodes = formattedMembers.flat()
+  reportAllErrors({
+    sortNodesExcludingEslintDisabled,
+    availableMessageIds,
+    options,
+    context,
+    nodes,
+  })
+}
+export { sortArray }

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

@@ -11,8 +11,7 @@ import { AllCommonOptions } from '../../types/all-common-options.js'
 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.
+     * Conditional configuration based on pattern matching.
      */
     useConfigurationIf: {
       /**
@@ -20,6 +19,10 @@ export type Options = Partial<
        * The rule is only applied when all names match this pattern.
        */
       allNamesMatchPattern?: RegexOption
+      /**
+       * AST selector to match against ArrayExpression nodes.
+       */
+      matchesAstSelector?: string
     }
   } & AllCommonOptions<
     TypeOption,

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

@@ -1,7 +1,4 @@
 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'
@@ -15,26 +12,14 @@ type MessageId =
   | typeof ORDER_ERROR_ID
 export declare let defaultOptions: Required<Options[number]>
 export declare let jsonSchema: JSONSchema4
-declare const _default: TSESLint.RuleModule<
+declare const _default: import('@typescript-eslint/utils/ts-eslint').RuleModule<
   MessageId,
   Options,
-  import('../utils/create-eslint-rule.js').ESLintPluginDocumentation,
-  TSESLint.RuleListener
+  {
+    recommended?: boolean
+  },
+  import('@typescript-eslint/utils/ts-eslint').RuleListener
 > & {
   name: string
 }
 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

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

@@ -1,4 +1,9 @@
 import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import {
+  buildUseConfigurationIfJsonSchema,
+  matchesAstSelectorJsonSchema,
+  buildCommonJsonSchemas,
+} from '../utils/json-schemas/common-json-schemas.js'
 import {
   partitionByNewLineJsonSchema,
   partitionByCommentJsonSchema,
@@ -9,34 +14,11 @@ import {
   EXTRA_SPACING_ERROR,
   MISSED_SPACING_ERROR,
 } from '../utils/report-errors.js'
-import {
-  buildUseConfigurationIfJsonSchema,
-  buildCommonJsonSchemas,
-} from '../utils/json-schemas/common-json-schemas.js'
-import { validateNewlinesAndPartitionConfiguration } from '../utils/validate-newlines-and-partition-configuration.js'
-import { defaultComparatorByOptionsComputer } from '../utils/compare/default-comparator-by-options-computer.js'
-import {
-  additionalCustomGroupMatchOptionsJsonSchema,
-  allSelectors,
-} from './sort-array-includes/types.js'
-import { buildOptionsByGroupIndexComputer } from '../utils/build-options-by-group-index-computer.js'
 import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
-import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration.js'
-import { filterOptionsByAllNamesMatch } from '../utils/filter-options-by-all-names-match.js'
-import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.js'
-import { generatePredefinedGroups } from '../utils/generate-predefined-groups.js'
-import { getEslintDisabledLines } from '../utils/get-eslint-disabled-lines.js'
-import { isNodeEslintDisabled } from '../utils/is-node-eslint-disabled.js'
-import { doesCustomGroupMatch } from '../utils/does-custom-group-match.js'
-import { sortNodesByGroups } from '../utils/sort-nodes-by-groups.js'
+import { additionalCustomGroupMatchOptionsJsonSchema } from './sort-array-includes/types.js'
+import { buildAstListeners } from '../utils/build-ast-listeners.js'
 import { createEslintRule } from '../utils/create-eslint-rule.js'
-import { reportAllErrors } from '../utils/report-all-errors.js'
-import { shouldPartition } from '../utils/should-partition.js'
-import { computeGroup } from '../utils/compute-group.js'
-import { rangeToDiff } from '../utils/range-to-diff.js'
-import { getSettings } from '../utils/get-settings.js'
-import { isSortable } from '../utils/is-sortable.js'
-import { complete } from '../utils/complete.js'
+import { sortArray } from './sort-array-includes/sort-array.js'
 let cachedGroupsByModifiersAndSelectors = /* @__PURE__ */ new Map()
 const ORDER_ERROR_ID = 'unexpectedArrayIncludesOrder'
 const GROUP_ORDER_ERROR_ID = 'unexpectedArrayIncludesGroupOrder'
@@ -66,7 +48,11 @@ let jsonSchema = {
         additionalCustomGroupMatchProperties:
           additionalCustomGroupMatchOptionsJsonSchema,
       }),
-      useConfigurationIf: buildUseConfigurationIfJsonSchema(),
+      useConfigurationIf: buildUseConfigurationIfJsonSchema({
+        additionalProperties: {
+          matchesAstSelector: matchesAstSelectorJsonSchema,
+        },
+      }),
       partitionByComment: partitionByCommentJsonSchema,
       partitionByNewLine: partitionByNewLineJsonSchema,
     },
@@ -77,31 +63,6 @@ let jsonSchema = {
   type: 'array',
 }
 const sortArrayIncludes = createEslintRule({
-  create: context => ({
-    MemberExpression: node => {
-      if (
-        (node.object.type === AST_NODE_TYPES.ArrayExpression ||
-          node.object.type === AST_NODE_TYPES.NewExpression) &&
-        node.property.type === AST_NODE_TYPES.Identifier &&
-        node.property.name === 'includes'
-      ) {
-        let elements =
-          node.object.type === AST_NODE_TYPES.ArrayExpression ?
-            node.object.elements
-          : node.object.arguments
-        sortArray({
-          availableMessageIds: {
-            missedSpacingBetweenMembers: MISSED_SPACING_ERROR_ID,
-            extraSpacingBetweenMembers: EXTRA_SPACING_ERROR_ID,
-            unexpectedGroupOrder: GROUP_ORDER_ERROR_ID,
-            unexpectedOrder: ORDER_ERROR_ID,
-          },
-          elements,
-          context,
-        })
-      }
-    },
-  }),
   meta: {
     messages: {
       [MISSED_SPACING_ERROR_ID]: MISSED_SPACING_ERROR,
@@ -118,110 +79,49 @@ const sortArrayIncludes = createEslintRule({
     type: 'suggestion',
     fixable: 'code',
   },
+  create: context =>
+    buildAstListeners({
+      nodeTypes: [AST_NODE_TYPES.NewExpression, AST_NODE_TYPES.ArrayExpression],
+      sorter: sortPotentiallyValidArray,
+      context,
+    }),
   defaultOptions: [defaultOptions],
   name: 'sort-array-includes',
 })
-function sortArray({ availableMessageIds, elements, context }) {
-  if (!isSortable(elements)) {
+function sortPotentiallyValidArray({ matchedAstSelectors, context, node }) {
+  if (!isValidArray()) {
     return
   }
-  let { sourceCode, id } = context
-  let settings = getSettings(context.settings)
-  let matchedContextOptions = filterOptionsByAllNamesMatch({
-    nodeNames: elements
-      .filter(element => element !== null)
-      .map(element => getNodeName({ sourceCode, element })),
-    contextOptions: context.options,
-  })
-  let options = complete(matchedContextOptions[0], settings, defaultOptions)
-  validateCustomSortConfiguration(options)
-  validateGroupsConfiguration({
-    selectors: allSelectors,
-    modifiers: [],
-    options,
-  })
-  validateNewlinesAndPartitionConfiguration(options)
-  let eslintDisabledLines = getEslintDisabledLines({
-    ruleName: id,
-    sourceCode,
-  })
-  let optionsByGroupIndexComputer = buildOptionsByGroupIndexComputer(options)
-  let formattedMembers = elements.reduce(
-    (accumulator, element) => {
-      if (element === null) {
-        return accumulator
-      }
-      if (element.type === AST_NODE_TYPES.SpreadElement) {
-        accumulator.push([])
-        return accumulator
-      }
-      let name = getNodeName({ sourceCode, element })
-      let selector = 'literal'
-      let predefinedGroups = generatePredefinedGroups({
-        cache: cachedGroupsByModifiersAndSelectors,
-        selectors: [selector],
-        modifiers: [],
-      })
-      let group = computeGroup({
-        customGroupMatcher: customGroup =>
-          doesCustomGroupMatch({
-            selectors: [selector],
-            elementName: name,
-            modifiers: [],
-            customGroup,
-          }),
-        predefinedGroups,
-        options,
-      })
-      let sortingNode = {
-        isEslintDisabled: isNodeEslintDisabled(element, eslintDisabledLines),
-        size: rangeToDiff(element, sourceCode),
-        node: element,
-        group,
-        name,
-      }
-      let lastSortingNode = accumulator.at(-1)?.at(-1)
-      if (
-        shouldPartition({
-          lastSortingNode,
-          sortingNode,
-          sourceCode,
-          options,
-        })
-      ) {
-        accumulator.push([])
-      }
-      accumulator.at(-1).push({
-        ...sortingNode,
-        partitionId: accumulator.length,
-      })
-      return accumulator
+  sortArray({
+    availableMessageIds: {
+      missedSpacingBetweenMembers: MISSED_SPACING_ERROR_ID,
+      extraSpacingBetweenMembers: EXTRA_SPACING_ERROR_ID,
+      unexpectedGroupOrder: GROUP_ORDER_ERROR_ID,
+      unexpectedOrder: ORDER_ERROR_ID,
     },
-    [[]],
-  )
-  function sortNodesExcludingEslintDisabled(ignoreEslintDisabledNodes) {
-    return formattedMembers.flatMap(nodes2 =>
-      sortNodesByGroups({
-        comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
-        optionsByGroupIndexComputer,
-        ignoreEslintDisabledNodes,
-        groups: options.groups,
-        nodes: nodes2,
-      }),
-    )
-  }
-  let nodes = formattedMembers.flat()
-  reportAllErrors({
-    sortNodesExcludingEslintDisabled,
-    availableMessageIds,
-    options,
+    cachedGroupsByModifiersAndSelectors,
+    matchedAstSelectors,
+    defaultOptions,
     context,
-    nodes,
+    node,
   })
+  function isValidArray() {
+    if (node.parent.type !== AST_NODE_TYPES.MemberExpression) {
+      return false
+    }
+    if (node.parent.property.type !== AST_NODE_TYPES.Identifier) {
+      return false
+    }
+    if (node.parent.property.name !== 'includes') {
+      return false
+    }
+    if (node.parent.parent.type !== AST_NODE_TYPES.CallExpression) {
+      return false
+    }
+    if (node.parent.parent.callee !== node.parent) {
+      return false
+    }
+    return true
+  }
 }
-function getNodeName({ sourceCode, element }) {
-  return element.type === AST_NODE_TYPES.Literal ?
-      `${element.value}`
-    : sourceCode.getText(element)
-}
-export { sortArrayIncludes as default, defaultOptions, jsonSchema, sortArray }
+export { sortArrayIncludes as default, defaultOptions, jsonSchema }

package/dist/rules/sort-classes/compute-dependencies-by-sorting-node.d.ts

@@ -17,11 +17,4 @@ export declare function computeDependenciesBySortingNode({
   sourceCode: TSESLint.SourceCode
   classBody: TSESTree.ClassBody
 }): Map<SortingNodeWithoutDependencies, SortingNodeWithoutDependencies[]>
-export declare function computeThisExpressionsInsideClassElement({
-  classElement,
-  sourceCode,
-}: {
-  classElement: TSESTree.ClassElement
-  sourceCode: TSESLint.SourceCode
-}): TSESTree.ThisExpression[]
 export {}

package/dist/rules/sort-classes/compute-dependencies-by-sorting-node.js

@@ -38,21 +38,6 @@ function computeDependenciesBySortingNode({
   }
   return dependenciesBySortingNode
 }
-function computeThisExpressionsInsideClassElement({
-  classElement,
-  sourceCode,
-}) {
-  let thisTokens = sourceCode.getTokens(classElement).filter(isThisToken)
-  return thisTokens
-    .map(computeTokenNode)
-    .filter(node => node?.type === AST_NODE_TYPES.ThisExpression)
-  function computeTokenNode(token) {
-    return sourceCode.getNodeByRangeIndex(token.range[0])
-  }
-  function isThisToken(token) {
-    return token.type === AST_TOKEN_TYPES.Keyword && token.value === 'this'
-  }
-}
 function computeIdentifierOrThisExpressionDependency({
   ignoreCallbackDependenciesPatterns,
   sortingNodes,
@@ -183,7 +168,19 @@ function shouldIgnoreDependencyComputation(node) {
       throw new UnreachableCaseError(node)
   }
 }
-export {
-  computeDependenciesBySortingNode,
-  computeThisExpressionsInsideClassElement,
+function computeThisExpressionsInsideClassElement({
+  classElement,
+  sourceCode,
+}) {
+  let thisTokens = sourceCode.getTokens(classElement).filter(isThisToken)
+  return thisTokens
+    .map(computeTokenNode)
+    .filter(node => node?.type === AST_NODE_TYPES.ThisExpression)
+  function computeTokenNode(token) {
+    return sourceCode.getNodeByRangeIndex(token.range[0])
+  }
+  function isThisToken(token) {
+    return token.type === AST_TOKEN_TYPES.Keyword && token.value === 'this'
+  }
 }
+export { computeDependenciesBySortingNode }

package/dist/rules/sort-classes/compute-matched-context-options.d.ts

@@ -0,0 +1,23 @@
+import { RuleContext } from '@typescript-eslint/utils/ts-eslint'
+import { TSESTree } from '@typescript-eslint/types'
+import { Options } from './types.js'
+/**
+ * Computes the matched context options for a given class node.
+ *
+ * @param params - Parameters.
+ * @param params.matchedAstSelectors - The matched AST selectors for a class
+ *   node.
+ * @param params.context - The rule context.
+ * @returns The matched context options or undefined if none match.
+ */
+export declare function computeMatchedContextOptions<
+  MessageIds extends string,
+>({
+  matchedAstSelectors,
+  classElements,
+  context,
+}: {
+  context: Readonly<RuleContext<MessageIds, Options>>
+  matchedAstSelectors: ReadonlySet<string>
+  classElements: TSESTree.ClassElement[]
+}): Options[number] | undefined