feat: respect numeric separators in natural sorting

Author: azat-io

test/sort-maps.test.ts

@@ -832,5 +832,71 @@ describe(RULE_NAME, () => {
       valid: ['new Map([[], []])', 'new Map()'],
       invalid: [],
     })
+
+    ruleTester.run(
+      `${RULE_NAME}: respect numeric separators with natural sorting`,
+      rule,
+      {
+        valid: [
+          {
+            code: dedent`
+               new Map([
+                [1, "first"],
+                [2, "second"],
+                [3, "third"],
+                [100, "hundredth"],
+                [1_000, "thousandth"],
+                [1_000_000, "millionth"]
+              ])
+            `,
+            options: [
+              {
+                type: 'natural',
+                order: 'asc',
+              },
+            ],
+          },
+        ],
+        invalid: [
+          {
+            code: dedent`
+               new Map([
+                [1, "first"],
+                [2, "second"],
+                [3, "third"],
+                [1_000, "thousandth"],
+                [100, "hundredth"],
+                [1_000_000, "millionth"]
+              ])
+            `,
+            output: dedent`
+               new Map([
+                [1, "first"],
+                [2, "second"],
+                [3, "third"],
+                [100, "hundredth"],
+                [1_000, "thousandth"],
+                [1_000_000, "millionth"]
+              ])
+            `,
+            options: [
+              {
+                type: 'natural',
+                order: 'asc',
+              },
+            ],
+            errors: [
+              {
+                messageId: 'unexpectedMapElementsOrder',
+                data: {
+                  left: '1_000',
+                  right: '100',
+                },
+              },
+            ],
+          },
+        ],
+      },
+    )
   })
 })

utils/compare.ts

@@ -28,8 +28,18 @@ export let compare = (
     sortingFunction = (aNode, bNode) =>
       formatString(aNode.name).localeCompare(formatString(bNode.name))
   } else if (options.type === 'natural') {
+    let prepareNumeric = (string: string) => {
+      let formattedNumberPattern = /^[+-]?[\d ,_]+(\.[\d ,_]+)?$/
+      if (formattedNumberPattern.test(string)) {
+        return string.replaceAll(/[ ,_]/g, '')
+      }
+      return string
+    }
     sortingFunction = (aNode, bNode) =>
-      naturalCompare(formatString(aNode.name), formatString(bNode.name))
+      naturalCompare(
+        prepareNumeric(formatString(aNode.name)),
+        prepareNumeric(formatString(bNode.name)),
+      )
   } else {
     sortingFunction = (aNode, bNode) => {
       let aSize = aNode.size