eslint-plugin-perfectionist 5.1.0 → 5.2.0

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

@@ -0,0 +1,195 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import { UnreachableCaseError } from '../../utils/unreachable-case-error.js'
+import { isArrowFunctionNode } from './is-arrow-function-node.js'
+function computeDependencies(node, dependencyDetection) {
+  let dependencies = []
+  checkNode(node)
+  return dependencies
+  function checkNode(nodeToCheck, options) {
+    switch (dependencyDetection.type) {
+      case 'hard':
+        if (
+          (nodeToCheck.type === AST_NODE_TYPES.MethodDefinition ||
+            isArrowFunctionNode(nodeToCheck)) &&
+          (!nodeToCheck.static ||
+            !dependencyDetection.searchStaticMethodsAndFunctionProperties)
+        ) {
+          return
+        }
+        break
+      case 'soft':
+        checkNodesForSoftDependencies()
+        break
+      /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+      default:
+        throw new UnreachableCaseError(dependencyDetection)
+    }
+    checkNodesForCommonDependencies()
+    function checkNodesForCommonDependencies() {
+      if (
+        !options?.ignoreNextIdentifier &&
+        nodeToCheck.type === AST_NODE_TYPES.Identifier
+      ) {
+        dependencies.push(nodeToCheck.name)
+      }
+      if ('alternate' in nodeToCheck && nodeToCheck.alternate) {
+        checkNode(nodeToCheck.alternate)
+      }
+      if ('argument' in nodeToCheck && nodeToCheck.argument) {
+        checkNode(nodeToCheck.argument)
+      }
+      if ('arguments' in nodeToCheck) {
+        traverseNode(nodeToCheck.arguments)
+      }
+      if ('body' in nodeToCheck && nodeToCheck.body) {
+        traverseNode(nodeToCheck.body)
+      }
+      if ('callee' in nodeToCheck) {
+        checkNode(nodeToCheck.callee)
+      }
+      if ('consequent' in nodeToCheck) {
+        traverseNode(nodeToCheck.consequent)
+      }
+      if ('declarations' in nodeToCheck) {
+        traverseNode(nodeToCheck.declarations)
+      }
+      if ('decorators' in nodeToCheck) {
+        traverseNode(nodeToCheck.decorators)
+      }
+      if ('elements' in nodeToCheck) {
+        let elements = nodeToCheck.elements.filter(
+          currentNode => currentNode !== null,
+        )
+        traverseNode(elements)
+      }
+      if (
+        'expression' in nodeToCheck &&
+        typeof nodeToCheck.expression !== 'boolean'
+      ) {
+        checkNode(nodeToCheck.expression)
+      }
+      if ('expressions' in nodeToCheck) {
+        traverseNode(nodeToCheck.expressions)
+      }
+      if ('init' in nodeToCheck && nodeToCheck.init) {
+        checkNode(nodeToCheck.init)
+      }
+      if ('initializer' in nodeToCheck && nodeToCheck.initializer) {
+        checkNode(nodeToCheck.initializer)
+      }
+      if ('left' in nodeToCheck) {
+        checkNode(nodeToCheck.left)
+      }
+      if ('members' in nodeToCheck) {
+        traverseNode(nodeToCheck.members)
+      }
+      if ('object' in nodeToCheck) {
+        checkNode(nodeToCheck.object)
+      }
+      if ('properties' in nodeToCheck) {
+        traverseNode(nodeToCheck.properties)
+      }
+      if ('right' in nodeToCheck) {
+        checkNode(nodeToCheck.right)
+      }
+      if ('superClass' in nodeToCheck && nodeToCheck.superClass) {
+        checkNode(nodeToCheck.superClass)
+      }
+      if ('test' in nodeToCheck && nodeToCheck.test) {
+        checkNode(nodeToCheck.test)
+      }
+      if (
+        'value' in nodeToCheck &&
+        nodeToCheck.value &&
+        typeof nodeToCheck.value === 'object' &&
+        'type' in nodeToCheck.value
+      ) {
+        checkNode(nodeToCheck.value)
+      }
+    }
+    function checkNodesForSoftDependencies() {
+      if ('checkType' in nodeToCheck) {
+        checkNode(nodeToCheck.checkType)
+      }
+      if ('constraint' in nodeToCheck && nodeToCheck.constraint) {
+        checkNode(nodeToCheck.constraint)
+      }
+      if ('declaration' in nodeToCheck && nodeToCheck.declaration) {
+        checkNode(nodeToCheck.declaration)
+      }
+      if ('elementTypes' in nodeToCheck) {
+        traverseNode(nodeToCheck.elementTypes)
+      }
+      if ('elementType' in nodeToCheck) {
+        checkNode(nodeToCheck.elementType)
+      }
+      if ('extends' in nodeToCheck) {
+        traverseNode(nodeToCheck.extends)
+      }
+      if ('extendsType' in nodeToCheck) {
+        checkNode(nodeToCheck.extendsType)
+      }
+      if ('exprName' in nodeToCheck) {
+        checkNode(nodeToCheck.exprName)
+      }
+      if ('falseType' in nodeToCheck) {
+        checkNode(nodeToCheck.falseType)
+      }
+      if ('key' in nodeToCheck) {
+        checkNode(nodeToCheck.key, { ignoreNextIdentifier: true })
+      }
+      if ('id' in nodeToCheck && nodeToCheck.id) {
+        checkNode(nodeToCheck.id)
+      }
+      if ('implements' in nodeToCheck) {
+        traverseNode(nodeToCheck.implements)
+      }
+      if ('indexType' in nodeToCheck) {
+        checkNode(nodeToCheck.indexType)
+      }
+      if ('name' in nodeToCheck && typeof nodeToCheck.name !== 'string') {
+        checkNode(nodeToCheck.name)
+      }
+      if ('objectType' in nodeToCheck) {
+        checkNode(nodeToCheck.objectType)
+      }
+      if ('params' in nodeToCheck) {
+        traverseNode(nodeToCheck.params, { ignoreNextIdentifier: true })
+      }
+      if ('returnType' in nodeToCheck && nodeToCheck.returnType) {
+        checkNode(nodeToCheck.returnType)
+      }
+      if ('trueType' in nodeToCheck) {
+        checkNode(nodeToCheck.trueType)
+      }
+      if ('typeAnnotation' in nodeToCheck && nodeToCheck.typeAnnotation) {
+        checkNode(nodeToCheck.typeAnnotation)
+      }
+      if ('typeArguments' in nodeToCheck && nodeToCheck.typeArguments) {
+        checkNode(nodeToCheck.typeArguments)
+      }
+      if ('typeName' in nodeToCheck) {
+        checkNode(nodeToCheck.typeName)
+      }
+      if ('typeParameters' in nodeToCheck && nodeToCheck.typeParameters) {
+        traverseNode(nodeToCheck.typeParameters)
+      }
+      if ('typeParameter' in nodeToCheck) {
+        checkNode(nodeToCheck.typeParameter)
+      }
+      if ('types' in nodeToCheck) {
+        traverseNode(nodeToCheck.types)
+      }
+    }
+  }
+  function traverseNode(nodeToTraverse, options) {
+    if (Array.isArray(nodeToTraverse)) {
+      for (let nodeItem of nodeToTraverse) {
+        traverseNode(nodeItem, options)
+      }
+    } else {
+      checkNode(nodeToTraverse, options)
+    }
+  }
+}
+export { computeDependencies }

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

@@ -0,0 +1,12 @@
+import { TSESTree } from '@typescript-eslint/types'
+/**
+ * Checks whether a node is a property or accessor node with an
+ * ArrowFunctionExpression value.
+ *
+ * @param node - The AST node to check.
+ * @returns True if the node is a property or accessor node with an
+ *   ArrowFunctionExpression value, false otherwise.
+ */
+export declare function isArrowFunctionNode(
+  node: TSESTree.Node,
+): node is TSESTree.PropertyDefinition | TSESTree.AccessorProperty

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

@@ -0,0 +1,10 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/types'
+import { isPropertyOrAccessorNode } from './is-property-or-accessor-node.js'
+function isArrowFunctionNode(node) {
+  return (
+    isPropertyOrAccessorNode(node) &&
+    node.value !== null &&
+    node.value.type === AST_NODE_TYPES.ArrowFunctionExpression
+  )
+}
+export { isArrowFunctionNode }

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

@@ -0,0 +1,11 @@
+import { TSESTree } from '@typescript-eslint/types'
+/**
+ * Checks whether a node is a PropertyDefinition or AccessorProperty.
+ *
+ * @param node - The AST node to check.
+ * @returns True if the node is a PropertyDefinition or AccessorProperty, false
+ *   otherwise.
+ */
+export declare function isPropertyOrAccessorNode(
+  node: TSESTree.Node,
+): node is TSESTree.PropertyDefinition | TSESTree.AccessorProperty

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

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

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

@@ -1,9 +1,11 @@
 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'
 /**
@@ -14,11 +16,18 @@ import { CommonGroupsOptions } from '../../types/common-groups-options.js'
  */
 export type SortModulesOptions = [
   Partial<
-    CommonGroupsOptions<SingleCustomGroup, Record<string, never>, TypeOption> &
-      CommonOptions<TypeOption> &
+    CommonGroupsOptions<
+      SingleCustomGroup,
+      Record<string, never>,
+      CustomTypeOption
+    > &
+      CommonOptions<CustomTypeOption> &
       CommonPartitionOptions
   >,
 ]
+/** Represents a sorting node for a module statement. */
+export type SortModulesSortingNode =
+  SortingNodeWithDependencies<TSESTree.ProgramStatement>
 /**
  * Union type of all available module member selectors. Used to categorize
  * different types of module-level declarations.
@@ -46,6 +55,7 @@ interface SingleCustomGroup {
   /** The type of module member this group applies to. */
   selector?: Selector
 }
+type CustomTypeOption = typeof USAGE_TYPE_OPTION | TypeOption
 /**
  * Complete list of available module member selectors. Used for validation and
  * JSON schema generation.
@@ -73,4 +83,5 @@ 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 const USAGE_TYPE_OPTION = 'usage'
 export {}

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

@@ -18,4 +18,10 @@ let singleCustomGroupJsonSchema = {
   selector: buildCustomGroupSelectorJsonSchema(allSelectors),
   decoratorNamePattern: buildRegexJsonSchema(),
 }
-export { allModifiers, allSelectors, singleCustomGroupJsonSchema }
+const USAGE_TYPE_OPTION = 'usage'
+export {
+  USAGE_TYPE_OPTION,
+  allModifiers,
+  allSelectors,
+  singleCustomGroupJsonSchema,
+}

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

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

package/dist/rules/sort-modules.js

@@ -10,21 +10,25 @@ import {
   partitionByNewLineJsonSchema,
   partitionByCommentJsonSchema,
 } from '../utils/json-schemas/common-partition-json-schemas.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 {
   allSelectors,
   allModifiers,
   singleCustomGroupJsonSchema,
+  USAGE_TYPE_OPTION,
 } from './sort-modules/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 { buildComparatorByOptionsComputer } from './sort-modules/build-comparator-by-options-computer.js'
 import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
 import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration.js'
+import { isPropertyOrAccessorNode } from './sort-modules/is-property-or-accessor-node.js'
 import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.js'
 import { buildCommonJsonSchemas } from '../utils/json-schemas/common-json-schemas.js'
 import { generatePredefinedGroups } from '../utils/generate-predefined-groups.js'
 import { sortNodesByDependencies } from '../utils/sort-nodes-by-dependencies.js'
 import { getEslintDisabledLines } from '../utils/get-eslint-disabled-lines.js'
+import { isArrowFunctionNode } from './sort-modules/is-arrow-function-node.js'
+import { computeDependencies } from './sort-modules/compute-dependencies.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'
@@ -33,7 +37,6 @@ import { createEslintRule } from '../utils/create-eslint-rule.js'
 import { getDecoratorName } from '../utils/get-decorator-name.js'
 import { reportAllErrors } from '../utils/report-all-errors.js'
 import { shouldPartition } from '../utils/should-partition.js'
-import { getEnumMembers } from '../utils/get-enum-members.js'
 import { getGroupIndex } from '../utils/get-group-index.js'
 import { computeGroup } from '../utils/compute-group.js'
 import { rangeToDiff } from '../utils/range-to-diff.js'
@@ -79,8 +82,11 @@ const sortModules = createEslintRule({
     schema: [
       {
         properties: {
-          ...buildCommonJsonSchemas(),
+          ...buildCommonJsonSchemas({
+            allowedAdditionalTypeValues: [USAGE_TYPE_OPTION],
+          }),
           ...buildCommonGroupsJsonSchemas({
+            allowedAdditionalTypeValues: [USAGE_TYPE_OPTION],
             singleCustomGroupJsonSchema,
           }),
           partitionByComment: partitionByCommentJsonSchema,
@@ -125,9 +131,9 @@ const sortModules = createEslintRule({
         if (isSortable(program.body)) {
           return analyzeModule({
             eslintDisabledLines,
+            module: program,
             sourceCode,
             options,
-            program,
             context,
           })
         }
@@ -141,11 +147,13 @@ function analyzeModule({
   eslintDisabledLines,
   sourceCode,
   options,
-  program,
   context,
+  module,
 }) {
+  let optionsByGroupIndexComputer =
+    buildDefaultOptionsByGroupIndexComputer(options)
   let formattedNodes = [[]]
-  for (let node of program.body) {
+  for (let node of module.body) {
     let parseNode = function (nodeToParse) {
       if ('declare' in nodeToParse && nodeToParse.declare) {
         modifiers.push('declare')
@@ -185,7 +193,7 @@ function analyzeModule({
           formattedNodes.push([])
           if (nodeToParse.body) {
             analyzeModule({
-              program: nodeToParse.body,
+              module: nodeToParse.body,
               eslintDisabledLines,
               sourceCode,
               options,
@@ -200,10 +208,7 @@ function analyzeModule({
         case AST_NODE_TYPES.TSEnumDeclaration:
           selector = 'enum'
           ;({ name } = nodeToParse.id)
-          dependencies = [
-            ...dependencies,
-            ...getEnumMembers(nodeToParse).flatMap(extractDependencies),
-          ]
+          dependencies = [...dependencies, ...extractDependencies(nodeToParse)]
           break
         case AST_NODE_TYPES.ClassDeclaration:
           selector = 'class'
@@ -218,13 +223,7 @@ function analyzeModule({
               decorator,
             }),
           )
-          dependencies = [
-            ...dependencies,
-            ...(nodeToParse.superClass && 'name' in nodeToParse.superClass
-              ? [nodeToParse.superClass.name]
-              : []),
-            ...extractDependencies(nodeToParse.body),
-          ]
+          dependencies = [...dependencies, ...extractDependencies(nodeToParse)]
           break
       }
     }
@@ -291,11 +290,13 @@ function analyzeModule({
   function sortNodesExcludingEslintDisabled(ignoreEslintDisabledNodes) {
     let nodesSortedByGroups = formattedNodes.flatMap(nodes2 =>
       sortNodesByGroups({
+        comparatorByOptionsComputer: buildComparatorByOptionsComputer({
+          ignoreEslintDisabledNodes,
+          sortingNodes: nodes2,
+        }),
         isNodeIgnored: sortingNode =>
           getGroupIndex(options.groups, sortingNode) === options.groups.length,
-        optionsByGroupIndexComputer:
-          buildDefaultOptionsByGroupIndexComputer(options),
-        comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
+        optionsByGroupIndexComputer,
         ignoreEslintDisabledNodes,
         groups: options.groups,
         nodes: nodes2,
@@ -321,127 +322,18 @@ function analyzeModule({
   })
 }
 function extractDependencies(expression) {
-  let dependencies = []
   let searchStaticMethodsAndFunctionProperties =
-    expression.type === 'ClassBody' &&
-    expression.body.some(
+    expression.type === AST_NODE_TYPES.ClassDeclaration &&
+    expression.body.body.some(
       classElement =>
-        classElement.type === 'StaticBlock' ||
+        classElement.type === AST_NODE_TYPES.StaticBlock ||
         (classElement.static &&
-          isPropertyOrAccessor(classElement) &&
-          !isArrowFunction(classElement)),
+          isPropertyOrAccessorNode(classElement) &&
+          !isArrowFunctionNode(classElement)),
     )
-  function checkNode(nodeValue) {
-    if (
-      (nodeValue.type === 'MethodDefinition' || isArrowFunction(nodeValue)) &&
-      (!nodeValue.static || !searchStaticMethodsAndFunctionProperties)
-    ) {
-      return
-    }
-    if ('decorators' in nodeValue) {
-      traverseNode(nodeValue.decorators)
-    }
-    if (
-      nodeValue.type === 'NewExpression' &&
-      nodeValue.callee.type === 'Identifier'
-    ) {
-      dependencies.push(nodeValue.callee.name)
-    }
-    if (nodeValue.type === 'Identifier') {
-      dependencies.push(nodeValue.name)
-    }
-    if (nodeValue.type === 'ConditionalExpression') {
-      checkNode(nodeValue.test)
-      checkNode(nodeValue.consequent)
-      checkNode(nodeValue.alternate)
-    }
-    if (
-      'expression' in nodeValue &&
-      typeof nodeValue.expression !== 'boolean'
-    ) {
-      checkNode(nodeValue.expression)
-    }
-    if ('object' in nodeValue) {
-      checkNode(nodeValue.object)
-    }
-    if ('callee' in nodeValue) {
-      checkNode(nodeValue.callee)
-    }
-    if ('init' in nodeValue && nodeValue.init) {
-      checkNode(nodeValue.init)
-    }
-    if ('body' in nodeValue && nodeValue.body) {
-      traverseNode(nodeValue.body)
-    }
-    if ('left' in nodeValue) {
-      checkNode(nodeValue.left)
-    }
-    if ('right' in nodeValue) {
-      checkNode(nodeValue.right)
-    }
-    if ('initializer' in nodeValue && nodeValue.initializer) {
-      checkNode(nodeValue.initializer)
-    }
-    if ('elements' in nodeValue) {
-      let elements = nodeValue.elements.filter(
-        currentNode => currentNode !== null,
-      )
-      for (let element of elements) {
-        traverseNode(element)
-      }
-    }
-    if ('argument' in nodeValue && nodeValue.argument) {
-      checkNode(nodeValue.argument)
-    }
-    if ('arguments' in nodeValue) {
-      for (let argument of nodeValue.arguments) {
-        checkNode(argument)
-      }
-    }
-    if ('declarations' in nodeValue) {
-      for (let declaration of nodeValue.declarations) {
-        checkNode(declaration)
-      }
-    }
-    if ('properties' in nodeValue) {
-      for (let property of nodeValue.properties) {
-        checkNode(property)
-      }
-    }
-    if (
-      'value' in nodeValue &&
-      nodeValue.value &&
-      typeof nodeValue.value === 'object' &&
-      'type' in nodeValue.value
-    ) {
-      checkNode(nodeValue.value)
-    }
-    if ('expressions' in nodeValue) {
-      for (let nodeExpression of nodeValue.expressions) {
-        checkNode(nodeExpression)
-      }
-    }
-  }
-  function traverseNode(nodeValue) {
-    if (Array.isArray(nodeValue)) {
-      for (let nodeItem of nodeValue) {
-        traverseNode(nodeItem)
-      }
-    } else {
-      checkNode(nodeValue)
-    }
-  }
-  checkNode(expression)
-  return dependencies
-}
-function isArrowFunction(node) {
-  return (
-    isPropertyOrAccessor(node) &&
-    node.value !== null &&
-    node.value.type === 'ArrowFunctionExpression'
-  )
-}
-function isPropertyOrAccessor(node) {
-  return node.type === 'PropertyDefinition' || node.type === 'AccessorProperty'
+  return computeDependencies(expression, {
+    searchStaticMethodsAndFunctionProperties,
+    type: 'hard',
+  })
 }
 export { sortModules as default }

package/dist/rules/sort-named-exports.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-named-imports.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-object-types/types.d.ts

@@ -1,7 +1,6 @@
 import { JSONSchema4 } from '@typescript-eslint/utils/json-schema'
 import { TSESTree } from '@typescript-eslint/types'
 import {
-  FallbackSortOption,
   CommonOptions,
   RegexOption,
   TypeOption,
@@ -46,33 +45,19 @@ export type Options = Partial<
        */
       hasNumericKeysOnly?: boolean
     }
-    /**
-     * Fallback sorting configuration for elements that don't match any group.
-     * Includes an additional option to sort by member value or name.
-     */
-    fallbackSort: FallbackSortOption<TypeOption> & {
-      sortBy?: 'value' | 'name'
-    }
-    /**
-     * Determines what to sort by when comparing object type members.
-     *
-     * - 'name': Sort by the member's property/method name
-     * - 'value': Sort by the member's type annotation value.
-     *
-     * @default 'name'
-     */
-    sortBy: 'value' | 'name'
   } & CommonGroupsOptions<
     SingleCustomGroup,
     {
-      /** Fallback sorting configuration for elements within custom groups. */
-      fallbackSort?: {
-        sortBy?: 'value' | 'name'
-      } & FallbackSortOption<TypeOption>
+      sortBy?: SortByOption
     },
     TypeOption
   > &
-    Omit<CommonOptions<TypeOption>, 'fallbackSort'> &
+    CommonOptions<
+      TypeOption,
+      {
+        sortBy: SortByOption
+      }
+    > &
     CommonPartitionOptions
 >[]
 /**
@@ -89,6 +74,7 @@ export interface SortObjectTypesSortingNode extends SortingNode<TSESTree.TypeEle
    */
   value: string
 }
+type SortByOption = 'value' | 'name'
 export declare let objectTypeParentTypes: readonly [
   TSESTree.AST_NODE_TYPES.TSTypeAliasDeclaration,
   TSESTree.AST_NODE_TYPES.TSInterfaceDeclaration,
@@ -119,13 +105,6 @@ interface SingleCustomGroup {
    * value. Only applicable to properties.
    */
   elementValuePattern?: RegexOption
-  /**
-   * Override sorting method for this specific group.
-   *
-   * - 'name': Sort by member name
-   * - 'value': Sort by type annotation value.
-   */
-  sortBy?: 'value' | 'name'
   /**
    * Array of modifiers that members must have to match this group. Only
    * modifiers allowed for the specified selector type are valid.

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

@@ -21,7 +21,6 @@ let singleCustomGroupJsonSchema = {
   modifiers: buildCustomGroupModifiersJsonSchema(allModifiers),
   selector: buildCustomGroupSelectorJsonSchema(allSelectors),
   elementValuePattern: buildRegexJsonSchema(),
-  sortBy: sortByJsonSchema,
 }
 export {
   allModifiers,

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

@@ -18,7 +18,9 @@ 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
 export declare function sortObjectTypeElements<MessageIds extends string>({
   availableMessageIds,