feat: support sorting by type in fallback sorting

docs/content/rules/sort-interfaces.mdx

@@ -162,6 +162,7 @@ Determines whether the sorted items should be in ascending or descending order.
   {
     type: 'alphabetical' | 'natural' | 'line-length' | 'custom' | 'unsorted'
     order?: 'asc' | 'desc'
+    sortBy?: 'name' | 'value'
   }
   ```
 </sub>
@@ -560,7 +561,7 @@ interface CustomGroupDefinition {
   groupName: string
   type?: 'alphabetical' | 'natural' | 'line-length' | 'unsorted'
   order?: 'asc' | 'desc'
-  fallbackSort?: { type: string; order?: 'asc' | 'desc' }
+  fallbackSort?: { type: string; order?: 'asc' | 'desc'; sortBy?: 'name' | 'value' }
   sortBy?: 'name' | 'value'
   newlinesInside?: 'always' | 'never'
   selector?: string
@@ -579,7 +580,7 @@ interface CustomGroupAnyOfDefinition {
   groupName: string
   type?: 'alphabetical' | 'natural' | 'line-length' | 'unsorted'
   order?: 'asc' | 'desc'
-  fallbackSort?: { type: string; order?: 'asc' | 'desc' }
+  fallbackSort?: { type: string; order?: 'asc' | 'desc'; sortBy?: 'name' | 'value' }
   sortBy?: 'name' | 'value'
   newlinesInside?: 'always' | 'never'
   anyOf: Array<{

docs/content/rules/sort-object-types.mdx

@@ -124,6 +124,7 @@ Determines whether the sorted items should be in ascending or descending order.
   {
     type: 'alphabetical' | 'natural' | 'line-length' | 'custom' | 'unsorted'
     order?: 'asc' | 'desc'
+    sortBy?: 'name' | 'value'
   }
   ```
 </sub>
@@ -507,7 +508,7 @@ interface CustomGroupDefinition {
   groupName: string
   type?: 'alphabetical' | 'natural' | 'line-length' | 'unsorted'
   order?: 'asc' | 'desc'
-  fallbackSort?: { type: string; order?: 'asc' | 'desc' }
+  fallbackSort?: { type: string; order?: 'asc' | 'desc'; sortBy?: 'name' | 'value' }
   sortBy?: 'name' | 'value'
   newlinesInside?: 'always' | 'never'
   selector?: string
@@ -526,7 +527,7 @@ interface CustomGroupAnyOfDefinition {
   groupName: string
   type?: 'alphabetical' | 'natural' | 'line-length' | 'unsorted'
   order?: 'asc' | 'desc'
-  fallbackSort?: { type: string; order?: 'asc' | 'desc' }
+  fallbackSort?: { type: string; order?: 'asc' | 'desc'; sortBy?: 'name' | 'value' }
   sortBy?: 'name' | 'value'
   newlinesInside?: 'always' | 'never'
   anyOf: Array<{

rules/sort-object-types.ts

@@ -17,7 +17,7 @@ import {
   partitionByNewLineJsonSchema,
   newlinesBetweenJsonSchema,
   customGroupsJsonSchema,
-  commonJsonSchemas,
+  buildCommonJsonSchemas,
   groupsJsonSchema,
   regexJsonSchema,
 } from '../utils/common-json-schemas'
@@ -68,7 +68,7 @@ type MESSAGE_ID =
   | 'unexpectedObjectTypesOrder'
 
 let defaultOptions: Required<Options[0]> = {
-  fallbackSort: { type: 'unsorted' },
+  fallbackSort: { type: 'unsorted', sortBy: 'name' },
   partitionByComment: false,
   partitionByNewLine: false,
   newlinesBetween: 'ignore',
@@ -89,11 +89,18 @@ let defaultOptions: Required<Options[0]> = {
 export let jsonSchema: JSONSchema4 = {
   items: {
     properties: {
-      ...commonJsonSchemas,
+      ...buildCommonJsonSchemas({
+        additionalFallbackSortProperties: {
+          sortBy: sortByJsonSchema,
+        },
+      }),
       customGroups: {
         oneOf: [
           customGroupsJsonSchema,
-          buildCustomGroupsArrayJsonSchema({ singleCustomGroupJsonSchema }),
+          buildCustomGroupsArrayJsonSchema({
+            additionalFallbackSortProperties: { sortBy: sortByJsonSchema },
+            singleCustomGroupJsonSchema,
+          }),
         ],
       },
       useConfigurationIf: buildUseConfigurationIfJsonSchema({
@@ -363,13 +370,17 @@ export let sortObjectTypeElements = <MessageIds extends string>({
       filteredGroupKindNodes.flatMap(groupedNodes =>
         sortNodesByGroups({
           getOptionsByGroupNumber: groupNumber => {
-            let { options: overriddenOptions, nodeValueGetter } =
-              getCustomGroupsCompareOptions(options, groupNumber)
+            let {
+              fallbackSortNodeValueGetter,
+              options: overriddenOptions,
+              nodeValueGetter,
+            } = getCustomGroupsCompareOptions(options, groupNumber)
             return {
               options: {
                 ...options,
                 ...overriddenOptions,
               },
+              fallbackSortNodeValueGetter,
               nodeValueGetter,
             }
           },

rules/sort-object-types/get-custom-groups-compare-options.ts

@@ -17,31 +17,43 @@ export let getCustomGroupsCompareOptions = (
     Required<Options[0]>,
     'fallbackSort' | 'sortBy' | 'order' | 'type'
   >
+  fallbackSortNodeValueGetter?: NodeValueGetterFunction<SortObjectTypesSortingNode> | null
   nodeValueGetter?: NodeValueGetterFunction<SortObjectTypesSortingNode> | null
 } => {
   let baseCompareOptions = baseGetCustomGroupsCompareOptions(
     options,
     groupNumber,
   )
 
-  let { customGroups, sortBy, groups } = options
+  let { fallbackSort, customGroups, sortBy, groups } = options
+  let fallbackSortBy = fallbackSort.sortBy
   if (Array.isArray(customGroups)) {
     let group = groups[groupNumber]
     let customGroup =
       typeof group === 'string'
         ? customGroups.find(currentGroup => group === currentGroup.groupName)
         : null
 
-    if (customGroup && 'sortBy' in customGroup && customGroup.sortBy) {
-      ;({ sortBy } = customGroup)
+    if (customGroup) {
+      fallbackSortBy = customGroup.fallbackSort?.sortBy ?? fallbackSortBy
+      if ('sortBy' in customGroup && customGroup.sortBy) {
+        ;({ sortBy } = customGroup)
+      }
     }
   }
 
   return {
     options: {
       ...baseCompareOptions,
+      fallbackSort: {
+        ...baseCompareOptions.fallbackSort,
+        sortBy: fallbackSortBy,
+      },
       sortBy,
     },
+    fallbackSortNodeValueGetter: fallbackSortBy
+      ? buildNodeValueGetter(fallbackSortBy)
+      : null,
     nodeValueGetter: buildNodeValueGetter(sortBy),
   }
 }

rules/sort-object-types/types.ts

@@ -6,6 +6,7 @@ import type {
   PartitionByCommentOption,
   NewlinesBetweenOption,
   CustomGroupsOption,
+  FallbackSortOption,
   CommonOptions,
   GroupsOptions,
   RegexOption,
@@ -21,13 +22,19 @@ import {
 
 export type Options = Partial<
   {
+    customGroups:
+      | CustomGroupsOption<
+          SingleCustomGroup,
+          {
+            fallbackSort?: { sortBy?: 'value' | 'name' } & FallbackSortOption
+          }
+        >
+      | DeprecatedCustomGroupsOption
     useConfigurationIf: {
       declarationMatchesPattern?: RegexOption
       allNamesMatchPattern?: RegexOption
     }
-    customGroups:
-      | CustomGroupsOption<SingleCustomGroup>
-      | DeprecatedCustomGroupsOption
+    fallbackSort: { sortBy?: 'value' | 'name' } & FallbackSortOption
     /**
      * @deprecated for {@link `groups`}
      */
@@ -41,7 +48,7 @@ export type Options = Partial<
      */
     ignorePattern: RegexOption
     sortBy: 'value' | 'name'
-  } & CommonOptions
+  } & Omit<CommonOptions, 'fallbackSort'>
 >[]
 
 export type SingleCustomGroup = (

test/rules/sort-interfaces.test.ts

@@ -1303,6 +1303,47 @@ describe(ruleName, () => {
                 }
               `,
             },
+            {
+              options: [
+                {
+                  customGroups: [
+                    {
+                      fallbackSort: {
+                        type: 'alphabetical',
+                        sortBy: 'value',
+                      },
+                      elementValuePattern: '^foo',
+                      type: 'line-length',
+                      groupName: 'foo',
+                    },
+                  ],
+                  type: 'alphabetical',
+                  groups: ['foo'],
+                  order: 'asc',
+                },
+              ],
+              errors: [
+                {
+                  data: {
+                    right: 'b',
+                    left: 'a',
+                  },
+                  messageId: 'unexpectedInterfacePropertiesOrder',
+                },
+              ],
+              output: dedent`
+                interface Interface {
+                  b: fooBar
+                  a: fooZar
+                }
+              `,
+              code: dedent`
+                interface Interface {
+                  a: fooZar
+                  b: fooBar
+                }
+              `,
+            },
           ],
           valid: [],
         },
@@ -5048,6 +5089,40 @@ describe(ruleName, () => {
               }
             `,
           },
+          {
+            errors: [
+              {
+                data: {
+                  right: 'bb',
+                  left: 'c',
+                },
+                messageId: 'unexpectedInterfacePropertiesOrder',
+              },
+            ],
+            options: [
+              {
+                ...options,
+                fallbackSort: {
+                  type: 'alphabetical',
+                  sortBy: 'value',
+                },
+              },
+            ],
+            output: dedent`
+              interface Interface {
+                bb: string;
+                c: boolean;
+                a: number;
+              }
+            `,
+            code: dedent`
+              interface Interface {
+                c: boolean;
+                bb: string;
+                a: number;
+              }
+            `,
+          },
         ],
         valid: [],
       },

test/rules/sort-object-types.test.ts

@@ -1044,6 +1044,47 @@ describe(ruleName, () => {
                 }
               `,
             },
+            {
+              options: [
+                {
+                  customGroups: [
+                    {
+                      fallbackSort: {
+                        type: 'alphabetical',
+                        sortBy: 'value',
+                      },
+                      elementValuePattern: '^foo',
+                      type: 'line-length',
+                      groupName: 'foo',
+                    },
+                  ],
+                  type: 'alphabetical',
+                  groups: ['foo'],
+                  order: 'asc',
+                },
+              ],
+              errors: [
+                {
+                  data: {
+                    right: 'b',
+                    left: 'a',
+                  },
+                  messageId: 'unexpectedObjectTypesOrder',
+                },
+              ],
+              output: dedent`
+                type Type = {
+                  b: fooBar
+                  a: fooZar
+                }
+              `,
+              code: dedent`
+                type Type = {
+                  a: fooZar
+                  b: fooBar
+                }
+              `,
+            },
           ],
           valid: [],
         },
@@ -4328,6 +4369,40 @@ describe(ruleName, () => {
               }
             `,
           },
+          {
+            errors: [
+              {
+                data: {
+                  right: 'bb',
+                  left: 'c',
+                },
+                messageId: 'unexpectedObjectTypesOrder',
+              },
+            ],
+            options: [
+              {
+                ...options,
+                fallbackSort: {
+                  type: 'alphabetical',
+                  sortBy: 'value',
+                },
+              },
+            ],
+            output: dedent`
+              type Type = {
+                bb: string;
+                c: boolean;
+                a: number;
+              }
+            `,
+            code: dedent`
+              type Type = {
+                c: boolean;
+                bb: string;
+                a: number;
+              }
+            `,
+          },
         ],
         valid: [],
       },