pre-commit

Author: abrantesarthur

src/partitionObjectArray.ts

@@ -54,11 +54,12 @@ type PartitionedArrayProperties<T, K extends keyof T> = {
  * //   rest: [{age: 25, city: 'NY'}, {age: 30, city: 'LA'}]
  * // }
  */
-  export const partitionObjectArray = <T extends object, K extends keyof T>(
-    items: T[],
-    properties: K[],
-  ): PartitionedArrayProperties<T, K> =>
-    items.reduce((acc, item) => {
+export const partitionObjectArray = <T extends object, K extends keyof T>(
+  items: T[],
+  properties: K[],
+): PartitionedArrayProperties<T, K> =>
+  items.reduce(
+    (acc, item) => {
       const result = { ...acc } as PartitionedArrayProperties<T, K>;
 
       properties.forEach((prop) => {
@@ -76,4 +77,6 @@ type PartitionedArrayProperties<T, K extends keyof T> = {
       result.rest = [...(acc.rest || []), restObject];
 
       return result;
-    }, {} as PartitionedArrayProperties<T, K>);
+    },
+    {} as PartitionedArrayProperties<T, K>,
+  );

src/tests/partitionObjectArray.test.ts

@@ -10,125 +10,118 @@ describe('partitionObjectArray', () => {
   it('should extract multiple properties from array of objects', () => {
     const items = [
       { id: 1, name: 'John', age: 25, city: 'NY' },
-      { id: 2, name: 'Jane', age: 30, city: 'LA' }
+      { id: 2, name: 'Jane', age: 30, city: 'LA' },
     ];
     const result = partitionObjectArray(items, ['id', 'name']);
     expect(result).to.deep.equal({
       id: [1, 2],
       name: ['John', 'Jane'],
       rest: [
         { age: 25, city: 'NY' },
-        { age: 30, city: 'LA' }
-      ]
+        { age: 30, city: 'LA' },
+      ],
     });
   });
 
   it('should handle objects with missing properties', () => {
     const items = [
       { id: 1, name: 'John', age: 25 },
       { id: 2, age: 30 },
-      { id: 3, name: 'Bob', city: 'LA' }
+      { id: 3, name: 'Bob', city: 'LA' },
     ];
     const result = partitionObjectArray(items, ['id', 'name']);
     expect(result).to.deep.equal({
       id: [1, 2, 3],
       name: ['John', undefined, 'Bob'],
-      rest: [
-        { age: 25 },
-        { age: 30 },
-        { city: 'LA' }
-      ]
+      rest: [{ age: 25 }, { age: 30 }, { city: 'LA' }],
     });
   });
 
   it('should handle different value types', () => {
     const items = [
       { id: 1, active: true, count: 10, tags: ['a', 'b'] },
-      { id: 2, active: false, count: 20, tags: ['c'] }
+      { id: 2, active: false, count: 20, tags: ['c'] },
     ];
     const result = partitionObjectArray(items, ['active', 'tags']);
     expect(result).to.deep.equal({
       active: [true, false],
       tags: [['a', 'b'], ['c']],
       rest: [
         { id: 1, count: 10 },
-        { id: 2, count: 20 }
-      ]
+        { id: 2, count: 20 },
+      ],
     });
   });
 
   it('should handle extracting all properties (empty rest)', () => {
     const items = [
       { id: 1, name: 'John' },
-      { id: 2, name: 'Jane' }
+      { id: 2, name: 'Jane' },
     ];
     const result = partitionObjectArray(items, ['id', 'name']);
     expect(result).to.deep.equal({
       id: [1, 2],
       name: ['John', 'Jane'],
-      rest: [{}, {}]
+      rest: [{}, {}],
     });
   });
 
   it('should handle extracting no properties (everything in rest)', () => {
     const items = [
       { id: 1, name: 'John' },
-      { id: 2, name: 'Jane' }
+      { id: 2, name: 'Jane' },
     ];
     const result = partitionObjectArray(items, []);
     expect(result).to.deep.equal({
       rest: [
         { id: 1, name: 'John' },
-        { id: 2, name: 'Jane' }
-      ]
+        { id: 2, name: 'Jane' },
+      ],
     });
   });
 
   it('should handle objects with null or undefined values', () => {
     const items = [
       { id: 1, name: null, age: 25 },
-      { id: 2, name: undefined, age: 30 }
+      { id: 2, name: undefined, age: 30 },
     ];
     const result = partitionObjectArray(items, ['id', 'name']);
     expect(result).to.deep.equal({
       id: [1, 2],
       name: [null, undefined],
-      rest: [
-        { age: 25 },
-        { age: 30 }
-      ]
+      rest: [{ age: 25 }, { age: 30 }],
     });
   });
 
   it('should handle nested objects', () => {
     const items = [
       { id: 1, user: { name: 'John', age: 25 } },
-      { id: 2, user: { name: 'Jane', age: 30 } }
+      { id: 2, user: { name: 'Jane', age: 30 } },
     ];
     const result = partitionObjectArray(items, ['id', 'user']);
     expect(result).to.deep.equal({
       id: [1, 2],
       user: [
         { name: 'John', age: 25 },
-        { name: 'Jane', age: 30 }
+        { name: 'Jane', age: 30 },
       ],
-      rest: [{}, {}]
+      rest: [{}, {}],
     });
   });
 
   it('should preserve property order in rest object', () => {
     const items = [
       { a: 1, b: 2, c: 3, d: 4 },
-      { a: 5, b: 6, c: 7, d: 8 }
+      { a: 5, b: 6, c: 7, d: 8 },
     ];
     const result = partitionObjectArray(items, ['a', 'c']);
     expect(result).to.deep.equal({
       a: [1, 5],
       c: [3, 7],
       rest: [
         { b: 2, d: 4 },
-        { b: 6, d: 8 }
-      ]
+        { b: 6, d: 8 },
+      ],
     });
   });
 });