Chris Chen
103 lines
3.3 KiB
TypeScript
103 lines
3.3 KiB
TypeScript
import { DropDownOption } from '../entity/dropDownOption';
|
|
|
|
export class ArrayUtils {
|
|
|
|
public static Equals(array1, array2) {
|
|
// if the other array is a falsy value, return
|
|
if (!array2)
|
|
return false;
|
|
|
|
// compare lengths - can save a lot of time
|
|
if (array1.length != array2.length)
|
|
return false;
|
|
|
|
for (var i = 0, l = array1.length; i < l; i++) {
|
|
// Check if we have nested arrays
|
|
if (array1[i] instanceof Array && array2[i] instanceof Array) {
|
|
// recurse into the nested arrays
|
|
if (!ArrayUtils.Equals(array1[i], array2[i]))
|
|
return false;
|
|
}
|
|
else if (array1[i] != array2[i]) {
|
|
// Warning - two different object instances will never be equal: {x:20} != {x:20}
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static ToDropDownOptions(array: any[], keyProperty: string | number, valueProperty: string | number): DropDownOption[] {
|
|
var result = [];
|
|
for (let i = 0; i < array.length; i++) {
|
|
const element = array[i];
|
|
result.push(new DropDownOption(element[keyProperty], element[valueProperty]));
|
|
}
|
|
return result;
|
|
}
|
|
public static MoveItem(arr: any[], old_index, new_index) {
|
|
if (new_index >= arr.length) {
|
|
var k = new_index - arr.length + 1;
|
|
while (k--) {
|
|
arr.push(undefined);
|
|
}
|
|
}
|
|
arr.splice(new_index, 0, arr.splice(old_index, 1)[0]);
|
|
};
|
|
|
|
public static GroupBy<T = any>(arr: Array<T>, groupKeyPrepareFunction: (obj: T) => any | any[]) {
|
|
|
|
let groups = arr.reduce(function (groupModel, obj) {
|
|
|
|
let keys = groupKeyPrepareFunction(obj);
|
|
|
|
const addToGroup = (key: any, obj: T) => {
|
|
let group = groupModel.find(g => g.key == key);
|
|
if (group == null) {
|
|
group = new GroupModel(key);
|
|
groupModel.push(group);
|
|
}
|
|
group.values.push(obj);
|
|
}
|
|
|
|
if (Array.isArray(keys)) {
|
|
for (let i = 0; i < keys.length; i++) {
|
|
const key = keys[i];
|
|
addToGroup(key, obj);
|
|
}
|
|
} else {
|
|
addToGroup(keys, obj);
|
|
}
|
|
return groupModel;
|
|
}, [] as GroupModel<T>[]);
|
|
return groups;
|
|
}
|
|
public static RemoveDuplicate<T>(objArray: T[], duplicateDetection: (a: T, b: T) => boolean) {
|
|
return objArray.filter((value, index, self) =>
|
|
index === self.findIndex((t) => duplicateDetection(t, value))
|
|
);
|
|
}
|
|
|
|
public static ConcatMultiArray<T>(arrays: T[][]): T[] {
|
|
return <T[]>[].concat.apply(<T[]>[], arrays.map(arr => arr));
|
|
}
|
|
|
|
public static insertAt = (arr: any[], index: number, newItems: any) => [
|
|
// part of the array before the specified index
|
|
...arr.slice(0, index),
|
|
// inserted items
|
|
newItems,
|
|
// part of the array after the specified index
|
|
...arr.slice(index)
|
|
];
|
|
|
|
}
|
|
|
|
export class GroupModel<T = any>{
|
|
constructor(key: any) {
|
|
this.key = key;
|
|
this.values = [];
|
|
}
|
|
|
|
key: any;
|
|
values: T[];
|
|
} |