Add moveObjectToFrontOfArray

Author: Andy Mitchell

src/main/index.ts

@@ -47,7 +47,7 @@ export {
 
 export * as EmailHelpers from "./email-helpers/index.ts";
 export * as PostgresHelpers from './db/postgres/index.js';
-
+export * from './moveObjectToFrontOfArray.ts'
 
 export type {
     EnsureAllMethodsAreAsync,

src/main/misc.test.ts

@@ -1,5 +1,6 @@
 import { convertArrayToRecord, getGlobal, promiseWithTrigger } from "./misc.ts"
 
+
 test('getGlobal', () => {
     const glob = getGlobal();
     expect(!!glob).toBe(true);
@@ -27,4 +28,5 @@ describe('convertArrayToRecord', () => {
         const result = convertArrayToRecord([{name: 'Bob'}], 'name');
         expect(result).toEqual({'Bob': {name: 'Bob'}})
     })
-})
+})
+

src/main/moveObjectToFrontOfArray.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from 'vitest';
+import { moveObjectToFront, moveObjectToFrontMutate } from './moveObjectToFrontOfArray.ts';
+
+testMoveObjectToFront('moveObjectToFront', moveObjectToFront, false);
+testMoveObjectToFront('moveObjectToFrontMutate', moveObjectToFrontMutate, true);
+
+
+/**
+ * Reusable test suite for any implementation of moveObjectToFront.
+ * 
+ * @param name - Name of the implementation being tested.
+ * @param moveFn - The function implementation to test.
+ * @param mutate - Whether the function mutates the original array.
+ */
+export function testMoveObjectToFront(
+    name: string,
+    moveFn: <T, K extends keyof T>(arr: T[], key: K, value: T[K]) => T[],
+    mutate: boolean
+) {
+    describe(name, () => {
+        it('moves matching item to front (single match)', () => {
+            const arr = [
+                { id: 'b' },
+                { id: 'a' },
+                { id: 'c' }
+            ];
+            const original = [...arr];
+            const result = moveFn(arr, 'id', 'a');
+            expect(result[0]!.id).toBe('a');
+            if (!mutate) expect(arr).toEqual(original);
+        });
+
+        it('it does not sort other keys', () => {
+            const arr = [
+                { id: 'z' },
+                { id: 'a' },
+                { id: 'y' }
+            ];
+            const original = [...arr];
+            const result = moveFn(arr, 'id', 'a');
+            expect(result[0]!.id).toBe('a');
+            expect(result[1]!.id).toBe('z');
+            expect(result[2]!.id).toBe('y');
+            if (!mutate) expect(arr).toEqual(original);
+        });
+
+        it('moves multiple matches to the front in order', () => {
+            const arr = [
+                { id: 'x' },
+                { id: 'a' },
+                { id: 'b' },
+                { id: 'a' },
+                { id: 'c' }
+            ];
+            const original = [...arr];
+            const result = moveFn(arr, 'id', 'a');
+            expect(result.slice(0, 2).map(obj => obj.id)).toEqual(['a', 'a']);
+            expect(result.length).toBe(5);
+            if (!mutate) expect(arr).toEqual(original);
+        });
+
+        it('leaves array unchanged if value not found', () => {
+            const arr = [
+                { id: 'x' },
+                { id: 'y' },
+                { id: 'z' }
+            ];
+            const original = [...arr];
+            const result = moveFn(arr, 'id', 'a');
+            expect(result).toEqual(arr);
+            if (!mutate) expect(arr).toEqual(original);
+        });
+
+        it('works with numeric keys and values', () => {
+            const arr = [
+                { rank: 2 },
+                { rank: 1 },
+                { rank: 3 },
+                { rank: 1 }
+            ];
+            const original = [...arr];
+            const result = moveFn(arr, 'rank', 1);
+            expect(result.slice(0, 2).map(o => o.rank)).toEqual([1, 1]);
+            if (!mutate) expect(arr).toEqual(original);
+        });
+
+        it('returns empty array if input is empty', () => {
+            const arr: { id: string }[] = [];
+            const result = moveFn(arr, 'id', 'a');
+            expect(result).toEqual([]);
+        });
+
+        it('double check mutation', () => {
+            const arr = [
+                { id: 'b' },
+                { id: 'a' },
+                { id: 'c' }
+            ];
+            const original = [...arr];
+            const result = moveFn(arr, 'id', 'a');
+            if (!mutate) expect(arr).toEqual(original);
+            if( mutate ) {
+                expect(result).toBe(arr);
+                expect(result).not.toBe(original);
+            }
+        });
+    });
+}

src/main/moveObjectToFrontOfArray.ts

@@ -0,0 +1,42 @@
+/**
+ * Returns a new array with all objects that match a specific key-value pair moved to the front.
+ *
+ * @template T - The object type in the array.
+ * @template K - The key of the object to match.
+ * @param {T[]} arr - The original array to process.
+ * @param {K} key - The key to match in the object.
+ * @param {T[K]} value - The value to match for the given key.
+ * @returns {T[]} A new array with matching objects first, followed by the rest.
+ */
+export function moveObjectToFront<T, K extends keyof T>(
+    arr: T[],
+    key: K,
+    value: T[K]
+  ): T[] {
+    return [
+      ...arr.filter(item => item[key] === value),
+      ...arr.filter(item => item[key] !== value),
+    ];
+  }
+  
+
+  /**
+ * Moves all objects with a specific key-value pair to the front of the array (in-place).
+ *
+ * @template T - The object type in the array.
+ * @template K - The key of the object to match.
+ * @param {T[]} arr - The array to mutate and sort.
+ * @param {K} key - The key to match in the object.
+ * @param {T[K]} value - The value to match for the given key.
+ * @returns {T[]} The same array with matching objects moved to the front.
+ */
+export function moveObjectToFrontMutate<T, K extends keyof T>(
+    arr: T[],
+    key: K,
+    value: T[K]
+  ): T[] {
+    return arr.sort((a, b) =>
+      a[key] === value ? -1 : b[key] === value ? 1 : 0
+    );
+  }
+