create function transposeObjectArray (#31)

* create function partitionObjectArray

* lint

* pre-commit

* rename to transposeObjectArray

* lint

* fix test

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 './transposeObjectArray';

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/transposeObjectArray.test.ts

@@ -0,0 +1,127 @@
+import { expect } from 'chai';
+import { transposeObjectArray } from '../transposeObjectArray';
+
+describe('transposeObjectArray', () => {
+  it('should handle empty array', () => {
+    const result = transposeObjectArray([], ['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 = transposeObjectArray(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 = transposeObjectArray(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 = transposeObjectArray(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 = transposeObjectArray(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 = transposeObjectArray(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 = transposeObjectArray(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 = transposeObjectArray(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 = transposeObjectArray(items, ['a', 'c']);
+    expect(result).to.deep.equal({
+      a: [1, 5],
+      c: [3, 7],
+      rest: [
+        { b: 2, d: 4 },
+        { b: 6, d: 8 },
+      ],
+    });
+  });
+});

src/transposeObjectArray.ts

@@ -0,0 +1,85 @@
+// eslint-disable-next-line eslint-comments/disable-enable-pair
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/**
+ * Type representing a transposed array of objects.
+ *
+ * For each selected property K from the original object type T:
+ * - Creates an array containing all values of that property
+ * - The array type matches the property's original type
+ * - Includes a 'rest' array containing all non-selected properties
+ * @template T - The source object type
+ * @template K - The keys to transpose into arrays
+ * @example
+ * // Original array of objects:
+ * const users = [
+ *   { id: 1, name: 'John', age: 25, city: 'NY' },
+ *   { id: 2, name: 'Jane', age: 30, city: 'LA' }
+ * ];
+ *
+ * // Type for transposing 'id' and 'name':
+ * type Result = TransposedObjectArray<typeof users[0], 'id' | 'name'>;
+ *
+ * // Resulting type structure:
+ * {
+ *   id: number[];      // Array of all IDs: [1, 2]
+ *   name: string[];    // Array of all names: ['John', 'Jane']
+ *   rest: Array<{      // Array of remaining properties
+ *     age: number;     // [{ age: 25, city: 'NY' },
+ *     city: string;    //  { age: 30, city: 'LA' }]
+ *   }>;
+ * }
+ */
+type TransposedObjectArray<T, K extends keyof T> = {
+  [P in K]: Array<T[P]>;
+} & {
+  /** Properties not selected for transposition */
+  rest: Array<Omit<T, K>>;
+};
+
+/**
+ * Transposes an array of objects by converting selected properties into 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 transpose
+ * @param items - Array of objects to transpose
+ * @param properties - Array of property keys to transpose into arrays
+ * @returns An object containing transposed arrays for each selected property
+ * @example
+ * const items = [
+ *   { id: 1, name: 'John', age: 25 },
+ *   { id: 2, name: 'Jane', age: 30 }
+ * ]
+ * const result = transposeObjectArray(items, ['id', 'name']);
+ * // Returns: {
+ * //   id: [1, 2],
+ * //   name: ['John', 'Jane'],
+ * //   rest: [{age: 25}, {age: 30}]
+ * // }
+ */
+export const transposeObjectArray = <T extends object, K extends keyof T>(
+  items: T[],
+  properties: K[],
+): TransposedObjectArray<T, K> =>
+  items.reduce(
+    (acc, item) => {
+      const result = { ...acc } as TransposedObjectArray<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 TransposedObjectArray<T, K>,
+  );