feat: improve sorting for arrays with mixed content types

josdejong · josdejong · commit 8ef2ed9f5292 · 2025-05-23T15:30:32.000+02:00
diff --git a/src/lib/logic/sort.test.ts b/src/lib/logic/sort.test.ts
@@ -10,6 +10,7 @@ import {
   sortOperationsMove,
   sortOperationsMoveAdvanced
 } from './sort.js'
+import { LosslessNumber } from 'lossless-json'
 
 describe('sort', () => {
   describe('sortJson', () => {
@@ -150,6 +151,47 @@ describe('sort', () => {
     ])
   })
 
+  test('should sort an array with mixed content', () => {
+    assert.deepStrictEqual(
+      sortArray([3, 'B', true, undefined, -1, false, { id: 2 }, 'A', [3], { id: 1 }, [2], 2]),
+      [
+        {
+          op: 'replace',
+          path: '',
+          value: [false, true, -1, 2, 3, 'A', 'B', { id: 2 }, [3], { id: 1 }, [2], undefined]
+        }
+      ]
+    )
+  })
+
+  test('should sort an array with non-primitive content', () => {
+    assert.deepStrictEqual(
+      sortArray([new LosslessNumber('5'), new LosslessNumber('3'), new LosslessNumber('7')]),
+      [
+        {
+          op: 'replace',
+          path: '',
+          value: [new LosslessNumber('3'), new LosslessNumber('5'), new LosslessNumber('7')]
+        }
+      ]
+    )
+  })
+
+  test('should sort an array with non-primitive large numbers', () => {
+    assert.deepStrictEqual(sortArray([new LosslessNumber('2e3'), new LosslessNumber('290')]), [
+      { op: 'replace', path: '', value: [new LosslessNumber('290'), new LosslessNumber('2e3')] }
+    ])
+  })
+
+  test.skip('should sort an array with non-primitive large numbers (2)', () => {
+    const twoE20 = new LosslessNumber('200000000000000000000')
+    const twoE20plus1 = new LosslessNumber('200000000000000000001')
+
+    assert.deepStrictEqual(sortArray([twoE20plus1, twoE20]), [
+      { op: 'replace', path: '', value: [twoE20, twoE20plus1] }
+    ])
+  })
+
   test('should sort array by nested properties and a direction', () => {
     const a = { data: { value: 1 } }
     const b = { data: { value: 2 } }
diff --git a/src/lib/logic/sort.ts b/src/lib/logic/sort.ts
@@ -13,7 +13,7 @@ import {
 import { first, initial, isEmpty, isEqual, last } from 'lodash-es'
 import naturalCompare from 'natural-compare-lite'
 import { int } from '../utils/numberUtils.js'
-import { isObject } from '../utils/typeUtils.js'
+import { isObject, isObjectOrArray } from '../utils/typeUtils.js'
 
 export function caseInsensitiveNaturalCompare(a: unknown, b: unknown) {
   const aLower = typeof a === 'string' ? a.toLowerCase() : a
@@ -123,24 +123,34 @@ export function sortArray(
  * Create a comparator function to compare nested properties in an array
  */
 function createObjectComparator(propertyPath: JSONPath, direction: 1 | -1) {
+  const sortableTypes: Record<string, number> = { boolean: 0, number: 1, string: 2, undefined: 4 }
+  const otherTypes = 3
+
   return function comparator(a: unknown, b: unknown) {
     const valueA = getIn(a, propertyPath)
     const valueB = getIn(b, propertyPath)
 
-    if (valueA === undefined) {
-      return direction
-    }
-    if (valueB === undefined) {
-      return -direction
+    // Order mixed types
+    if (typeof valueA !== typeof valueB) {
+      const aIndex = sortableTypes[typeof valueA] ?? otherTypes
+      const bIndex = sortableTypes[typeof valueB] ?? otherTypes
+
+      return aIndex > bIndex ? direction : aIndex < bIndex ? -direction : 0
     }
 
-    if (typeof valueA !== 'string' && typeof valueB !== 'string') {
-      // both values are a number, boolean, or null -> use simple, fast sorting
+    // Order two numbers, two strings, or two booleans
+    if (typeof valueA === 'number' || typeof valueA === 'boolean') {
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-ignore
       return valueA > valueB ? direction : valueA < valueB ? -direction : 0
     }
 
+    // Leave objects and arrays unsorted
+    if (isObjectOrArray(valueA)) {
+      return 0
+    }
+
+    // sort strings and non-primitive types
     return direction * caseInsensitiveNaturalCompare(valueA, valueB)
   }
 }
