73 lines
2.4 KiB
TypeScript
73 lines
2.4 KiB
TypeScript
/*
|
|
* Transforms object with arrays into array of objects
|
|
*
|
|
* @param {Record<string, any>} input - Object with arrays
|
|
* @param {string[]} ignoredKeys - Keys to ignore
|
|
* @returns {Record<string, any>[]} Array of objects
|
|
*
|
|
*/
|
|
export function objectWithArraysToArrayOfObjects(input: Record<string, any>, arraysToArrays: string[]): Record<string, any>[] {
|
|
arraysToArrays.forEach((k) => {
|
|
// Transform single array to array of arrays and keep array of arrays as is
|
|
if (Array.isArray(input[k]) && !Array.isArray(input[k][0])) {
|
|
input[k] = [input[k]];
|
|
}
|
|
});
|
|
const keys = Object.keys(input);
|
|
|
|
const maxLength = Math.max(
|
|
...keys.map((k) =>
|
|
Array.isArray(input[k]) ? (input[k] as any[]).length : 1
|
|
)
|
|
);
|
|
|
|
const output: Record<string, any>[] = [];
|
|
|
|
for (let i = 0; i < maxLength; i++) {
|
|
const event: Record<string, any> = {};
|
|
for (const k of keys) {
|
|
if (Array.isArray(input[k])) {
|
|
event[k] = (input[k] as any[])[i % (input[k] as any[]).length];
|
|
} else {
|
|
event[k] = input[k];
|
|
}
|
|
}
|
|
output.push(event);
|
|
}
|
|
return output;
|
|
};
|
|
|
|
/*
|
|
* Transforms array of objects into object with arrays
|
|
*
|
|
* @param {Record<string, any>[]} array - Array of objects
|
|
* @param {Record<string, any>} mergeObject - Object that is merged to each object in the array
|
|
* @returns {object} Merged object with arrays
|
|
*
|
|
*/
|
|
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) => {
|
|
obj[key as keyof T] = mergeObject[key];
|
|
});
|
|
Object.keys(obj).forEach((key) => {
|
|
if (!acc[key as keyof T]) {
|
|
acc[key as keyof T] = [];
|
|
}
|
|
(acc[key as keyof T] as unknown[]).push(obj[key]);
|
|
});
|
|
return acc;
|
|
}, {} as Record<keyof T, any[]>);
|
|
}
|
|
|
|
/*
|
|
* Filter certain keys from object
|
|
*
|
|
* @param {Record<string, any>} obj - Object to filter
|
|
* @param {string[]} filter - Keys to filter
|
|
* @returns {object} Filtered object
|
|
*
|
|
*/
|
|
export function filterObject(obj: Record<string, any>, filter: string[]): Record<string, any> {
|
|
return Object.fromEntries(Object.entries(obj).filter(([key]) => filter.includes(key)));
|
|
} |