create function partitionObjectArray

Author: abrantesarthur

package.json

@@ -2,7 +2,7 @@
   "author": "Transcend Inc.",
   "name": "@transcend-io/type-utils",
   "description": "Small package containing useful typescript utilities.",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "homepage": "https://github.com/transcend-io/type-utils",
   "repository": {
     "type": "git",

src/index.ts

@@ -12,4 +12,5 @@ export * from './types';
 export * from './valuesOf';
 export * from './findAllWithRegex';
 export * from './flattenObject';
-export * from './aggregateObjects';
+export * from './aggregateObjects';
+export * from './partitionObjectArray';

src/partitionObjectArray.ts

@@ -0,0 +1,83 @@
+// eslint-disable-next-line eslint-comments/disable-enable-pair
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/**
+  * Type that represents the partitioned properties from an object type T.
+ * For each selected property K from T, creates an array of that property's type.
+ * Also includes a 'rest' property containing an array of objects with all non-selected properties.
+ *
+ * @template T - The source object type
+ * @template K - The keys to partition from T
+ * @example
+ * // Given an array of objects:
+ * const items = [
+ *   { id: 1, name: 'John', age: 25, city: 'NY' },
+ *   { id: 2, name: 'Jane', age: 30, city: 'LA' }
+ * ];
+ *
+ * // And selecting 'id' and 'name':
+ * type Result = PartitionedArrayProperties<typeof items[0], 'id' | 'name'>;
+ *
+ * // Result will be typed as:
+ * {
+ *   id: number[];        // [1, 2]
+ *   name: string[];      // ['John', 'Jane']
+ *   rest: Array<{        // [{ age: 25, city: 'NY' }, { age: 30, city: 'LA' }]
+ *     age: number;
+ *     city: string;
+ *   }>;
+ * }
+ */
+type PartitionedArrayProperties<T, K extends keyof T> = {
+  [P in K]: Array<T[P]>;
+} & {
+  /** The array of remaining properties not selected for partitioning */
+  rest: Array<Omit<T, K>>;
+};
+  
+/**
+ * Partitions an array of objects by separating specified properties into their own arrays
+ * while keeping the remaining properties grouped in a 'rest' array.
+ *
+ * @template T - The type of objects in the input array
+ * @template K - The keys of properties to partition
+ * @param items - Array of objects to partition
+ * @param properties - Array of property keys to separate into their own arrays
+ * @returns An object containing arrays for each selected property and a rest array for remaining properties
+ * @example
+ * const items = [
+ *   { id: 1, name: 'John', age: 25, city: 'NY' },
+ *   { id: 2, name: 'Jane', age: 30, city: 'LA' }
+ * ]
+ * const result = partitionObjectArray(items, ['id', 'name']);
+ * // Returns: { 
+ * //   id: [1, 2], 
+ * //   name: ['John', 'Jane'], 
+ * //   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) => {
+      const result = { ...acc } as PartitionedArrayProperties<T, K>;
+  
+      properties.forEach((prop) => {
+        const currentArray = (acc[prop] || []) as T[K][];
+        result[prop] = [...currentArray, item[prop]] as any;
+      });
+  
+      const restObject = {} as Omit<T, K>;
+      Object.entries(item).forEach(([key, value]) => {
+        if (!properties.includes(key as K)) {
+          (restObject as any)[key] = value;
+        }
+      });
+  
+      result.rest = [...(acc.rest || []), restObject];
+  
+      return result;
+    }, {} as PartitionedArrayProperties<T, K>);
+  
+  

src/tests/aggregateObjects.test.ts

@@ -1,7 +1,7 @@
 import { expect } from 'chai';
 import { aggregateObjects } from '../aggregateObjects';
 
-describe.only('aggregateObjects', () => {
+describe('aggregateObjects', () => {
   it('should return empty object for empty input array', () => {
     const result = aggregateObjects({ objs: [] });
     expect(result).to.deep.equal({});

src/tests/flattenObject.test.ts

@@ -118,4 +118,4 @@ describe('flattenObject', () => {
       user_grandParents: '',
     });
   });
-});
+});

src/tests/partitionObjectArray.test.ts

@@ -0,0 +1,135 @@
+import { expect } from 'chai';
+import { partitionObjectArray } from '../partitionObjectArray';
+
+
+describe('partitionObjectArray', () => {
+  it('should handle empty array', () => {
+    const result = partitionObjectArray([], ['id', 'name']);
+    expect(result).to.deep.equal({});
+  });
+
+  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' }
+    ];
+    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' }
+      ]
+    });
+  });
+
+  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' }
+    ];
+    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' }
+      ]
+    });
+  });
+
+  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'] }
+    ];
+    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 }
+      ]
+    });
+  });
+
+  it('should handle extracting all properties (empty rest)', () => {
+    const items = [
+      { id: 1, name: 'John' },
+      { id: 2, name: 'Jane' }
+    ];
+    const result = partitionObjectArray(items, ['id', 'name']);
+    expect(result).to.deep.equal({
+      id: [1, 2],
+      name: ['John', 'Jane'],
+      rest: [{}, {}]
+    });
+  });
+
+  it('should handle extracting no properties (everything in rest)', () => {
+    const items = [
+      { id: 1, name: 'John' },
+      { id: 2, name: 'Jane' }
+    ];
+    const result = partitionObjectArray(items, []);
+    expect(result).to.deep.equal({
+      rest: [
+        { id: 1, name: 'John' },
+        { 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 }
+    ];
+    const result = partitionObjectArray(items, ['id', 'name']);
+    expect(result).to.deep.equal({
+      id: [1, 2],
+      name: [null, undefined],
+      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 } }
+    ];
+    const result = partitionObjectArray(items, ['id', 'user']);
+    expect(result).to.deep.equal({
+      id: [1, 2],
+      user: [
+        { name: 'John', age: 25 },
+        { name: 'Jane', age: 30 }
+      ],
+      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 }
+    ];
+    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 }
+      ]
+    });
+  });
+});