Trying to optimize generics

src/Utils/Generic.ts

@@ -6,36 +6,41 @@
  * @returns {Record<string, any>[]} Array of objects
  *
  */
-export function objectWithArraysToArrayOfObjects(input: Record<string, any>, arraysToArrays: string[]): Record<string, any>[] {
+export function objectWithArraysToArrayOfObjects(
+  input: Record<string, any>,
+  arraysToArrays: string[]
+): Record<string, any>[] {
+  const inputCopy = { ...input };
   arraysToArrays.forEach((k) => {
-        // Transform single array to array of arrays and keep array of arrays as is
+    if (Array.isArray(inputCopy[k]) && !Array.isArray(inputCopy[k][0])) {
-        if (Array.isArray(input[k]) && !Array.isArray(input[k][0])) {
+      inputCopy[k] = [inputCopy[k]];
-            input[k] = [input[k]];
     }
   });
-    const keys = Object.keys(input);
 
-    const maxLength = Math.max(
+  const keysAndLengths = Object.entries(inputCopy).reduce(
-      ...keys.map((k) =>
+    (acc, [key, value]) => {
-        Array.isArray(input[k]) ? (input[k] as any[]).length : 1
+      const length = Array.isArray(value) ? (value as any[]).length : 1;
-      )
+      acc.maxLength = Math.max(acc.maxLength, length);
+      acc.keys.push(key);
+      return acc;
+    },
+    { keys: [] as string[], maxLength: 0 }
   );
 
   const output: Record<string, any>[] = [];
-
+  for (let i = 0; i < keysAndLengths.maxLength; i++) {
-    for (let i = 0; i < maxLength; i++) {
     const event: Record<string, any> = {};
-      for (const k of keys) {
+    for (const k of keysAndLengths.keys) {
-        if (Array.isArray(input[k])) {
+      if (Array.isArray(inputCopy[k])) {
-            event[k] = (input[k] as any[])[i % (input[k] as any[]).length];
+        event[k] = (inputCopy[k] as any[])[i % (inputCopy[k] as any[]).length];
       } else {
-            event[k] = input[k];
+        event[k] = inputCopy[k];
       }
     }
     output.push(event);
   }
   return output;
-  };
+}
 
 /*
  * Transforms array of objects into object with arrays
@@ -45,22 +50,23 @@ export function objectWithArraysToArrayOfObjects(input: Record<string, any>, arr
  * @returns {object} Merged object with arrays
  *
  */
-export function arrayOfObjectsToObjectWithArrays<T extends Record<string, any>>(array: T[], mergeObject: Record<string, any> = {}): Record<string, any> {
+export function arrayOfObjectsToObjectWithArrays<T extends Record<string, any>>(
+  array: T[],
+  mergeObject: Record<string, any> = {}
+): Record<string, any> {
   return array.reduce((acc, obj) => {
-      Object.keys(mergeObject).forEach((key) => {
+    const mergedObj = { ...obj, ...mergeObject };
-        obj[key as keyof T] = mergeObject[key];
+    Object.keys(mergedObj).forEach((key) => {
-      });
+      if (!acc[key]) {
-      Object.keys(obj).forEach((key) => {
+        acc[key] = [];
-        if (!acc[key as keyof T]) {
-          acc[key as keyof T] = [];
       }
-        (acc[key as keyof T] as unknown[]).push(obj[key]);
+      acc[key].push(mergedObj[key]);
     });
     return acc;
-    }, {} as Record<keyof T, any[]>);
+  }, {} as Record<string, any>);
-  }
+}
 
-  /* 
+/*
  * Filter certain keys from object
  *
  * @param {Record<string, any>} obj - Object to filter
@@ -68,6 +74,11 @@ export function arrayOfObjectsToObjectWithArrays<T extends Record<string, any>>(
  * @returns {object} Filtered object
  *
  */
-  export function filterObject(obj: Record<string, any>, filter: string[]): Record<string, any> {
+export function filterObject(
-    return Object.fromEntries(Object.entries(obj).filter(([key]) => filter.includes(key)));
+  obj: Record<string, any>,
-  }
+  filter: string[]
+): Record<string, any> {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([key]) => filter.includes(key))
+  );
+}