fix: fix sorting switch cases with default in middle of group

Author: azat-io

rules/sort-switch-case.ts

@@ -184,18 +184,27 @@ export default createEslintRule<Options, MESSAGE_ID>({
 
                 let sortedNodeGroups = nodeGroups
                   .map(group => {
-                    let sortedGroup = sortNodes(group, options)
+                    let sortedGroup = sortNodes(group, options).sort((a, b) => {
+                      if (b.name === 'default') {
+                        return -1
+                      }
+                      return 1
+                    })
 
                     if (group.at(-1)!.name !== sortedGroup.at(-1)!.name) {
+                      let consequentNodeIndex = sortedGroup.findIndex(
+                        currentNode => currentNode.node.consequent.length !== 0,
+                      )
                       let firstSortedNodeConsequent =
-                        sortedGroup.at(0)!.node.consequent
+                        sortedGroup.at(consequentNodeIndex)!.node.consequent
                       let consequentStart = firstSortedNodeConsequent
                         .at(0)
                         ?.range.at(0)
                       let consequentEnd = firstSortedNodeConsequent
                         .at(-1)
                         ?.range.at(1)
                       let lastNode = group.at(-1)!.node
+
                       if (consequentStart && consequentEnd && lastNode.test) {
                         lastNode.range = [
                           lastNode.range.at(0)!,

test/sort-switch-case.test.ts

@@ -481,6 +481,56 @@ describe(ruleName, () => {
         },
       ],
     })
+
+    ruleTester.run(
+      `${ruleName}(${type}): works with groups with default`,
+      rule,
+      {
+        valid: [
+          {
+            code: dedent`
+            switch (x) {
+              case 'AA':
+              case 'B':
+              default:
+                const c = 3
+            }
+          `,
+            options: [options],
+          },
+        ],
+        invalid: [
+          {
+            code: dedent`
+            switch (x) {
+              case 'AA':
+              default:
+              case 'B':
+                break;
+            }
+          `,
+            output: dedent`
+            switch (x) {
+              case 'AA':
+              case 'B':
+              default:
+                break;
+            }
+          `,
+            options: [options],
+            errors: [
+              {
+                messageId: 'unexpectedSwitchCaseOrder',
+                data: {
+                  left: 'default',
+                  right: 'B',
+                },
+              },
+            ],
+          },
+        ],
+      },
+    )
   })
 
   describe(`${ruleName}: sorting by natural order`, () => {
@@ -948,6 +998,56 @@ describe(ruleName, () => {
         },
       ],
     })
+
+    ruleTester.run(
+      `${ruleName}(${type}): works with groups with default`,
+      rule,
+      {
+        valid: [
+          {
+            code: dedent`
+            switch (x) {
+              case 'AA':
+              case 'B':
+              default:
+                const c = 3
+            }
+          `,
+            options: [options],
+          },
+        ],
+        invalid: [
+          {
+            code: dedent`
+            switch (x) {
+              case 'AA':
+              default:
+              case 'B':
+                break;
+            }
+          `,
+            output: dedent`
+            switch (x) {
+              case 'AA':
+              case 'B':
+              default:
+                break;
+            }
+          `,
+            options: [options],
+            errors: [
+              {
+                messageId: 'unexpectedSwitchCaseOrder',
+                data: {
+                  left: 'default',
+                  right: 'B',
+                },
+              },
+            ],
+          },
+        ],
+      },
+    )
   })
 
   describe(`${ruleName}: sorting by line length`, () => {
@@ -1414,6 +1514,56 @@ describe(ruleName, () => {
         },
       ],
     })
+
+    ruleTester.run(
+      `${ruleName}(${type}): works with groups with default`,
+      rule,
+      {
+        valid: [
+          {
+            code: dedent`
+            switch (x) {
+              case 'AA':
+              case 'B':
+              default:
+                const c = 3
+            }
+          `,
+            options: [options],
+          },
+        ],
+        invalid: [
+          {
+            code: dedent`
+            switch (x) {
+              case 'AA':
+              default:
+              case 'B':
+                break;
+            }
+          `,
+            output: dedent`
+            switch (x) {
+              case 'AA':
+              case 'B':
+              default:
+                break;
+            }
+          `,
+            options: [options],
+            errors: [
+              {
+                messageId: 'unexpectedSwitchCaseOrder',
+                data: {
+                  left: 'default',
+                  right: 'B',
+                },
+              },
+            ],
+          },
+        ],
+      },
+    )
   })
 
   describe(`${ruleName}: misc`, () => {