Fix sort() method to perform a stable sort

Author: lahmatiy

CHANGELOG.md

@@ -7,6 +7,7 @@
 - Disallowed a backslash before closing quote or apostrophe in string literals
 - Improved error locations in string literals
 - Fixed `match()` method to work well for RegExp with `g` flag and for strings when `matchAll` is true
+- Fixed `sort()` method to perform a stable sort for old js-engines and always place `undefined` values last
 - Fixed range in details for bad input errors
 - Fixed suggestion support in template literals (#33)
 - Fixed suggestions for `=` and `!=` operators by avoiding unfold array values

src/lang/compile-buildin.js

@@ -8,6 +8,7 @@ const TYPE_STRING = 4;
 const TYPE_NULL = 5;
 const TYPE_OBJECT = 6;
 const TYPE_OTHER = 7;
+const TYPE_UNDEFINED = 8;
 
 function cmpType(value) {
     switch (typeof value) {
@@ -19,6 +20,8 @@ function cmpType(value) {
             return TYPE_STRING;
         case 'object':
             return value === null ? TYPE_NULL : TYPE_OBJECT;
+        case 'undefined':
+            return TYPE_UNDEFINED;
         default:
             return TYPE_OTHER;
     }

src/methods.js

@@ -17,6 +17,34 @@ function matchEntry(match) {
     };
 }
 
+const stableSortSize = isSortStable(20) ? Infinity : isSortStable(10) ? 10 : 0;
+
+function isSortStable(n) {
+    return Array.from({ length: n }, (_, idx) => ({ idx }))
+        .sort((a, b) => (a.idx % 2) - (b.idx % 2))
+        .every((a, idx) =>
+            idx < n / 2 ? (a.idx >> 1 === idx) : Math.ceil(n / 2) + (a.idx >> 1) === idx
+        );
+}
+
+function stableSort(array, cmp) {
+    // check size, e.g. old v8 had stable sort only for arrays with length less or equal 10
+    if (array.length <= stableSortSize) {
+        return array.slice().sort(cmp);
+    }
+
+    return array
+        .map((value, idx) => ({ value, idx }))
+        .sort((a, b) =>
+            (a.value === undefined
+                ? b.value !== undefined
+                : b.value === undefined
+                    ? -1
+                    : cmp(a.value, b.value)) || (a.idx - b.idx)
+        )
+        .map(item => item.value);
+}
+
 export default Object.freeze({
     bool: buildin.bool,
     filter: buildin.filter,
@@ -97,9 +125,11 @@ export default Object.freeze({
 
                 return a < b ? -1 : a > b;
             };
+        } else {
+            sorter = buildin.cmp;
         }
 
-        return current.slice().sort(sorter);
+        return stableSort(current, sorter);
     },
     reverse(current) {
         if (!Array.isArray(current)) {

test/method-sort.js

@@ -142,6 +142,7 @@ describe('sort()', () => {
     });
 
     describe('mixed value types', () => {
+        const filterUndefined = (arr) => arr.filter(x => x !== undefined);
         const fn = () => {};
         const data = [
             true,
@@ -162,47 +163,70 @@ describe('sort()', () => {
         ];
 
         it('asc', () => {
+            const expected = [
+                false,
+                true,
+                NaN,
+                -Infinity,
+                1,
+                4,
+                Infinity,
+                '2',
+                'b',
+                'z',
+                null,
+                { c: 1 },
+                { b: 1 },
+                fn,
+                undefined
+            ];
+
             assert.deepEqual(
-                escapeNaN(query('sort($ asc)')(data)),
-                escapeNaN([
-                    false,
-                    true,
-                    NaN,
-                    -Infinity,
-                    1,
-                    4,
-                    Infinity,
-                    '2',
-                    'b',
-                    'z',
-                    null,
-                    { c: 1 },
-                    { b: 1 },
-                    fn,
-                    undefined
-                ])
+                escapeNaN(query('sort()')(data)),
+                escapeNaN(expected)
+            );
+            assert.deepEqual(
+                escapeNaN(query('sort()')(filterUndefined(data))),
+                escapeNaN(filterUndefined(expected))
             );
         });
         it('desc', () => {
+            const expected = [
+                fn,
+                { c: 1 },
+                { b: 1 },
+                null,
+                'z',
+                'b',
+                '2',
+                Infinity,
+                4,
+                1,
+                -Infinity,
+                NaN,
+                true,
+                false,
+                undefined
+            ];
+
+            assert.deepEqual(
+                escapeNaN(query('sort($ desc)')(data)),
+                escapeNaN(expected)
+            );
+            assert.deepEqual(
+                escapeNaN(query('sort($ desc)')(filterUndefined(data))),
+                escapeNaN(filterUndefined(expected))
+            );
+        });
+
+        it('undefined should be always last', () => {
             assert.deepEqual(
-                escapeNaN(query('sort($ desc)')([...data])),
-                escapeNaN([
-                    fn,
-                    { c: 1 },
-                    { b: 1 },
-                    null,
-                    'z',
-                    'b',
-                    '2',
-                    Infinity,
-                    4,
-                    1,
-                    -Infinity,
-                    NaN,
-                    true,
-                    false,
-                    undefined
-                ])
+                query('sort()')([
+                    1, 'zzz', undefined, 4, 'asd', undefined, 3, undefined, 2
+                ]),
+                [
+                    1, 2, 3, 4, 'asd', 'zzz', undefined, undefined, undefined
+                ]
             );
         });
     });