feat: todo

Author: hugop95

rules/sort-enums.ts

@@ -1,8 +1,6 @@
 import type { TSESTree } from '@typescript-eslint/types'
 
-import type { NodeValueGetterFunction } from '../utils/compare/compare'
 import type { SortEnumsSortingNode, Options } from './sort-enums/types'
-import type { TypeOption } from '../types/common-options'
 
 import {
   buildCustomGroupsArrayJsonSchema,
@@ -20,13 +18,13 @@ import {
   ORDER_ERROR,
 } from '../utils/report-errors'
 import { validateNewlinesAndPartitionConfiguration } from '../utils/validate-newlines-and-partition-configuration'
-import { getCustomGroupOverriddenOptions } from '../utils/build-default-options-by-group-index-computer'
+import { buildDefaultOptionsByGroupIndexComputer } from '../utils/build-default-options-by-group-index-computer'
+import { buildComparatorByOptionsComputer } from './sort-enums/build-comparator-by-options-computer'
 import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration'
 import { sortNodesByDependencies } from '../utils/sort-nodes-by-dependencies'
 import { getEslintDisabledLines } from '../utils/get-eslint-disabled-lines'
 import { isNodeEslintDisabled } from '../utils/is-node-eslint-disabled'
 import { doesCustomGroupMatch } from '../utils/does-custom-group-match'
-import { UnreachableCaseError } from '../utils/unreachable-case-error'
 import { sortNodesByGroups } from '../utils/sort-nodes-by-groups'
 import { singleCustomGroupJsonSchema } from './sort-enums/types'
 import { createEslintRule } from '../utils/create-eslint-rule'
@@ -198,29 +196,15 @@ export default createEslintRule<Options, MessageId>({
         sortingNode => sortingNode.numericValue !== null,
       )
 
-      let nodeValueGetter = computeNodeValueGetter({
-        isNumericEnum,
-        options,
-      })
-      let overriddenOptions = {
-        ...options,
-        type: computeOptionType({
-          isNumericEnum,
-          options,
-        }),
-      }
       function sortNodesExcludingEslintDisabled(
         ignoreEslintDisabledNodes: boolean,
       ): SortEnumsSortingNode[] {
         let nodesSortedByGroups = formattedMembers.flatMap(sortingNodes =>
           sortNodesByGroups({
-            optionsByGroupIndexComputer: groupIndex => ({
-              options: getCustomGroupOverriddenOptions({
-                options: overriddenOptions,
-                groupIndex,
-              }),
-              nodeValueGetter,
-            }),
+            optionsByGroupIndexComputer:
+              buildDefaultOptionsByGroupIndexComputer(options),
+            comparatorByOptionsComputer:
+              buildComparatorByOptionsComputer(isNumericEnum),
             ignoreEslintDisabledNodes,
             groups: options.groups,
             nodes: sortingNodes,
@@ -329,35 +313,6 @@ function getBinaryExpressionNumberValue(
   }
 }
 
-function computeNodeValueGetter({
-  isNumericEnum,
-  options,
-}: {
-  options: Pick<Required<Options[number]>, 'sortByValue'>
-  isNumericEnum: boolean
-}): NodeValueGetterFunction<SortEnumsSortingNode> | null {
-  switch (options.sortByValue) {
-    case 'ifNumericEnum':
-      if (!isNumericEnum) {
-        return null
-      }
-      break
-    case 'always':
-      break
-    case 'never':
-      return null
-    /* v8 ignore next 2 */
-    default:
-      throw new UnreachableCaseError(options.sortByValue)
-  }
-  return sortingNode => {
-    if (isNumericEnum) {
-      return sortingNode.numericValue!.toString()
-    }
-    return sortingNode.value ?? ''
-  }
-}
-
 function getExpressionNumberValue(expression: TSESTree.Node): number | null {
   switch (expression.type) {
     case 'BinaryExpression':
@@ -398,23 +353,3 @@ function getUnaryExpressionNumberValue(
       return null
   }
 }
-
-function computeOptionType({
-  isNumericEnum,
-  options,
-}: {
-  options: Pick<Required<Options[number]>, 'sortByValue' | 'type'>
-  isNumericEnum: boolean
-}): TypeOption {
-  /**
-   * If the enum is numeric, and we sort by value, always use the `natural` sort
-   * type, which will correctly sort them.
-   */
-  if (!isNumericEnum) {
-    return options.type
-  }
-  if (options.sortByValue === 'never') {
-    return options.type
-  }
-  return 'natural'
-}

rules/sort-enums/build-comparator-by-options-computer.ts

@@ -0,0 +1,90 @@
+import type { ComparatorByOptionsComputer } from '../../utils/compare/default-comparator-by-options-computer'
+import type { SortEnumsSortingNode, Options } from './types'
+
+import { defaultComparatorByOptionsComputer } from '../../utils/compare/default-comparator-by-options-computer'
+import { compareAlphabetically } from '../../utils/compare/compare-alphabetically'
+import { compareByCustomSort } from '../../utils/compare/compare-by-custom-sort'
+import { compareByLineLength } from '../../utils/compare/compare-by-line-length'
+import { computeNaturalSort } from '../../utils/compare/compute-natural-sort'
+import { unsortedComparator } from '../../utils/compare/unsorted-comparator'
+import { UnreachableCaseError } from '../../utils/unreachable-case-error'
+
+export function buildComparatorByOptionsComputer(
+  isNumericEnum: boolean,
+): ComparatorByOptionsComputer<
+  Required<Options[number]>,
+  SortEnumsSortingNode
+> {
+  return options => {
+    switch (options.sortByValue) {
+      case 'ifNumericEnum':
+        if (isNumericEnum) {
+          return byNumericValueComparatorComputer(options)
+        }
+        return defaultComparatorByOptionsComputer(options)
+      case 'always':
+        if (isNumericEnum) {
+          return byNumericValueComparatorComputer(options)
+        }
+        return byNonNumericValueComparatorComputer(options)
+      case 'never':
+        return defaultComparatorByOptionsComputer(options)
+      default: {
+        throw new UnreachableCaseError(options.sortByValue)
+      }
+    }
+  }
+}
+
+let byNonNumericValueComparatorComputer: ComparatorByOptionsComputer<
+  Required<Options[number]>,
+  SortEnumsSortingNode
+> = options => {
+  switch (options.type) {
+    case 'alphabetical':
+      return (a, b) =>
+        compareAlphabetically(
+          a.value?.toString() ?? '',
+          b.value?.toString() ?? '',
+          options,
+        )
+    case 'line-length':
+      return (a, b) => compareByLineLength(a, b, options)
+    case 'unsorted':
+      return unsortedComparator
+    case 'natural':
+      return (a, b) =>
+        computeNaturalSort(
+          a.value?.toString() ?? '',
+          b.value?.toString() ?? '',
+          options,
+        )
+    case 'custom':
+      return (a, b) =>
+        compareByCustomSort(a.value ?? '', b.value ?? '', options)
+    default:
+      throw new UnreachableCaseError(options.type)
+  }
+}
+
+let byNumericValueComparatorComputer: ComparatorByOptionsComputer<
+  Required<Options[number]>,
+  SortEnumsSortingNode
+> = options => {
+  switch (options.type) {
+    case 'alphabetical':
+    case 'line-length':
+    case 'natural':
+    case 'custom':
+      return (a, b) =>
+        computeNaturalSort(
+          a.numericValue!.toString(),
+          b.numericValue!.toString(),
+          options,
+        )
+    case 'unsorted':
+      return unsortedComparator
+    default:
+      throw new UnreachableCaseError(options.type)
+  }
+}

rules/sort-imports.ts

@@ -309,11 +309,11 @@ export default createEslintRule<Options, MessageId>({
             ): SortImportsSortingNode[] {
               let nodesSortedByGroups = nodeGroups.flatMap(nodes =>
                 sortNodesByGroups({
-                  isNodeIgnoredForGroup: ({ groupIndex }) => {
+                  isNodeIgnoredForGroup: ({ group }) => {
                     if (options.sortSideEffects) {
                       return false
                     }
-                    return isSideEffectOnlyGroup(options.groups[groupIndex])
+                    return isSideEffectOnlyGroup(group)
                   },
                   optionsByGroupIndexComputer:
                     buildDefaultOptionsByGroupIndexComputer(options),

rules/sort-object-types.ts

@@ -36,8 +36,9 @@ import {
 } from '../utils/report-errors'
 import { validateNewlinesAndPartitionConfiguration } from '../utils/validate-newlines-and-partition-configuration'
 import { filterOptionsByDeclarationCommentMatches } from '../utils/filter-options-by-declaration-comment-matches'
+import { buildOptionsByGroupIndexComputer } from './sort-object-types/build-options-by-group-index-computer'
 import { validateGeneratedGroupsConfiguration } from '../utils/validate-generated-groups-configuration'
-import { getCustomGroupsCompareOptions } from './sort-object-types/get-custom-groups-compare-options'
+import { comparatorByOptionsComputer } from './sort-object-types/comparator-by-options-computer'
 import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration'
 import { filterOptionsByAllNamesMatch } from '../utils/filter-options-by-all-names-match'
 import { generatePredefinedGroups } from '../utils/generate-predefined-groups'
@@ -312,21 +313,6 @@ export function sortObjectTypeElements<MessageIds extends string>({
   ): SortObjectTypesSortingNode[] {
     return formattedMembers.flatMap(groupedNodes =>
       sortNodesByGroups({
-        optionsByGroupIndexComputer: groupIndex => {
-          let {
-            fallbackSortNodeValueGetter,
-            options: overriddenOptions,
-            nodeValueGetter,
-          } = getCustomGroupsCompareOptions(options, groupIndex)
-          return {
-            options: {
-              ...options,
-              ...overriddenOptions,
-            },
-            fallbackSortNodeValueGetter,
-            nodeValueGetter,
-          }
-        },
         isNodeIgnoredForGroup: ({ groupOptions, node }) => {
           switch (groupOptions.sortBy) {
             case 'value':
@@ -338,6 +324,8 @@ export function sortObjectTypeElements<MessageIds extends string>({
               throw new UnreachableCaseError(groupOptions.sortBy)
           }
         },
+        optionsByGroupIndexComputer: buildOptionsByGroupIndexComputer(options),
+        comparatorByOptionsComputer,
         ignoreEslintDisabledNodes,
         groups: options.groups,
         nodes: groupedNodes,

rules/sort-object-types/build-node-value-getter.ts

@@ -0,0 +1,59 @@
+import type { OptionsByGroupIndexComputer } from '../../utils/sort-nodes-by-groups'
+import type { Options } from './types'
+
+import { computeOverriddenOptionsByGroupIndex } from '../../utils/build-default-options-by-group-index-computer'
+import { computeGroupName } from '../../utils/compute-group-name'
+
+export function buildOptionsByGroupIndexComputer(
+  options: Required<Options[number]>,
+): OptionsByGroupIndexComputer<Required<Options[number]>> {
+  return groupIndex => computeOptionsForGroupIndex(options, groupIndex)
+}
+
+/**
+ * Retrieves sorting options for a specific group with object-type-specific
+ * overrides.
+ *
+ * Extends the base custom groups functionality to support 'sortBy' option,
+ * which determines whether to sort object type members by their key name or
+ * value. Custom groups can override both the primary sortBy and fallback sortBy
+ * settings.
+ *
+ * @param options - Rule options including custom groups configuration.
+ * @param groupIndex - Index of the group to get options for.
+ * @returns Sorting options with appropriate node value getters for the sort
+ *   strategy.
+ */
+function computeOptionsForGroupIndex(
+  options: Required<Options[number]>,
+  groupIndex: number,
+): Required<Options[number]> {
+  let overriddenOptions = computeOverriddenOptionsByGroupIndex(
+    options,
+    groupIndex,
+  )
+
+  let { fallbackSort, customGroups, sortBy, groups } = options
+  let fallbackSortBy = fallbackSort.sortBy
+  let group = groups[groupIndex]
+  let groupName = group ? computeGroupName(group) : null
+  let customGroup = customGroups.find(
+    currentGroup => groupName === currentGroup.groupName,
+  )
+
+  if (customGroup) {
+    fallbackSortBy = customGroup.fallbackSort?.sortBy ?? fallbackSortBy
+    if ('sortBy' in customGroup && customGroup.sortBy) {
+      ;({ sortBy } = customGroup)
+    }
+  }
+
+  return {
+    ...overriddenOptions,
+    fallbackSort: {
+      ...overriddenOptions.fallbackSort,
+      ...(fallbackSortBy ? { sortBy: fallbackSortBy } : {}),
+    },
+    sortBy,
+  }
+}

rules/sort-object-types/build-options-by-group-index-computer.ts

@@ -0,0 +1,46 @@
+import type { ComparatorByOptionsComputer } from '../../utils/compare/default-comparator-by-options-computer'
+import type { SortObjectTypesSortingNode, Options } from './types'
+
+import { defaultComparatorByOptionsComputer } from '../../utils/compare/default-comparator-by-options-computer'
+import { compareAlphabetically } from '../../utils/compare/compare-alphabetically'
+import { compareByCustomSort } from '../../utils/compare/compare-by-custom-sort'
+import { compareByLineLength } from '../../utils/compare/compare-by-line-length'
+import { computeNaturalSort } from '../../utils/compare/compute-natural-sort'
+import { unsortedComparator } from '../../utils/compare/unsorted-comparator'
+import { UnreachableCaseError } from '../../utils/unreachable-case-error'
+
+export let comparatorByOptionsComputer: ComparatorByOptionsComputer<
+  Required<Options[number]>,
+  SortObjectTypesSortingNode
+> = options => {
+  switch (options.sortBy) {
+    case 'value':
+      return byValueComparatorComputer(options)
+    case 'name':
+      return defaultComparatorByOptionsComputer(options)
+    default:
+      throw new UnreachableCaseError(options.sortBy)
+  }
+}
+
+let byValueComparatorComputer: ComparatorByOptionsComputer<
+  Required<Options[number]>,
+  SortObjectTypesSortingNode
+> = options => {
+  switch (options.type) {
+    case 'alphabetical':
+      return (a, b) =>
+        compareAlphabetically(a.value ?? '', b.value ?? '', options)
+    case 'line-length':
+      return (a, b) => compareByLineLength(a, b, options)
+    case 'unsorted':
+      return unsortedComparator
+    case 'natural':
+      return (a, b) => computeNaturalSort(a.value ?? '', b.value ?? '', options)
+    case 'custom':
+      return (a, b) =>
+        compareByCustomSort(a.value ?? '', b.value ?? '', options)
+    default:
+      throw new UnreachableCaseError(options.type)
+  }
+}