inviton-powerduck 0.0.154 → 0.0.155

package/common/utils/array-extend.ts

@@ -1,215 +0,0 @@
-import { arraySort } from './array-sort';
-
-export interface ArrayExtended<T> extends Array<T> {
-	/**
-	 * Removes given items from the Array
-	 *
-	 * @param items Items that should be removed from the Array
-	 */
-	remove: (...items: T[]) => void;
-
-	/**
-	 * Inserts item into the Array at given index
-	 *
-	 * @param items Item that should be added to the Array
-	 * @param index Index at which the item should be added
-	 */
-	insertAt: (item: T, index: number) => void;
-
-	/**
-	 * Clones current array into new instance
-	 */
-	clone: () => ArrayExtended<T>;
-
-	/**
-	 * Sorts array by given property
-	 *
-	 * @param propName Property name (or function returning the sort key), the array should be sorted by
-	 */
-	sortBy: (propName: string | ((item: T) => string | number)) => ArrayExtended<T>;
-
-	/**
-	 * Determines if current array contains given object
-	 *
-	 * @param str Obj that should be checked
-	 */
-	contains: (item: T) => boolean;
-
-	/**
-	 * LINQ Min function equivalent - returns lowest value from the collection
-	 *
-	 * @param callbackfn Lambda containing the desired property
-	 * @param defaultValue Default value for case when sequence contains no elements
-	 *
-	 */
-	min: (callbackfn: (value: T, index: number, array: T[]) => number, defaultValue?: number) => number;
-
-	/**
-	 * LINQ Max function equivalent - returns highest value from the collection
-	 *
-	 * @param callbackfn Lambda containing the desired property
-	 * @param defaultValue Default value for case when sequence contains no elements
-	 *
-	 */
-	max: (callbackfn: (value: T, index: number, array: T[]) => number, defaultValue?: number) => number;
-
-	/**
-	 * LINQ Sum function equivalent - returns sum of the collection
-	 *
-	 * @param callbackfn Lambda containing the desired property
-	 * @param defaultValue Default value for case when sequence contains no elements
-	 *
-	 */
-	sum: (callbackfn: (value: T, index: number, array: T[]) => number, defaultValue?: number) => number;
-
-	/**
-	 * LINQ SelectMany function equivalent - returns flatten collection of array's subcollection
-	 *
-	 * @param callbackfn Lambda containing the desired property
-	 * @param thisArg
-	 */
-	selectMany: <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U;
-
-	/**
-	 * LINQ Distinct function equivalent - returns array with distinct items
-	 *
-	 * @param callbackfn Lambda containing the desired property
-	 * @param thisArg
-	 */
-	distinct: <U>() => U;
-}
-
-if (!(Array.prototype as any).find) {
-	(Array.prototype as any).find = function (callback, ...args) {
-		const list = new Object(this);
-		const length = (list as any).length >>> 0;
-		const thisArg = args[0];
-		for (let i = 0; i < length; i++) {
-			const element = list[i];
-			if (callback.call(
-				thisArg,
-				element,
-				i,
-				list,
-			)) {
-				return element;
-			}
-		}
-	};
-}
-
-export const arrayExtend = <T>(arr: T[]): ArrayExtended<T> => {
-	if (arr == null) {
-		arr = [];
-	}
-
-	((arr as any)).remove = (items: [], ...args): void => {
-		for (let i = 0, len = args.length; i < len; i++) {
-			const item = args[i];
-			const itemIndex = arr.indexOf(item);
-
-			if (itemIndex > -1) {
-				arr.splice(itemIndex, 1);
-			}
-		}
-	};
-
-	((arr as any)).clone = function () {
-		return arrayExtend(this.slice(0));
-	};
-
-	((arr as any)).insertAt = (item, index) => {
-		arr.splice(
-			index,
-			0,
-			item,
-		);
-	};
-
-	((arr as any)).contains = (item) => {
-		if (item != null) {
-			let idProp = 'Id';
-			if (item[idProp] == null) {
-				idProp = 'id';
-			}
-
-			const idVal = item[idProp];
-			if (idVal != null && arr.length > 0) {
-				for (let i = 0, len = arr.length; i < len; i++) {
-					if (arr[i][idProp] == idVal) {
-						return true;
-					}
-				}
-			}
-		}
-
-		return arr.includes(item);
-	};
-
-	((arr as any)).min = <T>(callbackfn: (value: T, index: number, array: T[]) => number, defaultValue?: number): number => {
-		if (arr.length == 0) {
-			return defaultValue;
-		}
-
-		return arr.reduce((
-			prevVal,
-			u,
-			i,
-		) => Math.min(prevVal, callbackfn(
-			u as any,
-			i,
-			arr as any,
-		)), Number.MAX_VALUE);
-	};
-
-	((arr as any)).max = <T>(callbackfn: (value: T, index: number, array: T[]) => number, defaultValue?: number): number => {
-		if (arr.length == 0) {
-			return defaultValue;
-		}
-
-		return arr.reduce((
-			prevVal,
-			u,
-			i,
-		) => Math.max(prevVal, callbackfn(
-			u as any,
-			i,
-			arr as any,
-		)), 0);
-	};
-
-	((arr as any)).sum = <T>(callbackfn: (value: T, index: number, array: T[]) => number, defaultValue?: number): number => {
-		if (arr.length == 0) {
-			return defaultValue;
-		}
-
-		return arr.reduce((
-			prevVal,
-			u,
-			i,
-		) => prevVal + callbackfn(
-			u as any,
-			i,
-			arr as any,
-		), 0);
-	};
-
-	((arr as any)).selectMany = (callback): any => arr.reduce((
-		prevVal,
-		u,
-		i,
-	) => [
-		...prevVal,
-		...(callback(
-			u,
-			i,
-			arr,
-		) as any),
-	], []);
-
-	((arr as any)).distinct = (): any => arr.reduce((un, u) => ({ ...un, u }), {});
-
-	((arr as any)).sortBy = <T>(propName: string | ((item: T) => string | number)): ArrayExtended<T> => arraySort(arr as any, propName) as any;
-
-	return arr as any;
-};

package/common/utils/array-remove.ts

@@ -1,10 +0,0 @@
-export function arrayRemove<T>(arr: T[], ...items: T[]) {
-	for (let i = 1, len = arguments.length; i < len; i++) {
-		const item = arguments[i];
-		const itemIndex = arr.indexOf(item);
-
-		if (itemIndex > -1) {
-			arr.splice(itemIndex, 1);
-		}
-	}
-}

package/common/utils/array-sort.ts

@@ -1,56 +0,0 @@
-export function arraySort<T>(arr: T[], propName: string | ((item: T) => string | number)): Array<T> {
-	function dynamicSort(property) {
-		if (propName && {}.toString.call(propName) === '[object Function]') {
-			return function (a, b) {
-				let v1 = (<any>propName)(a);
-				let v2 = (<any>propName)(b);
-
-				if (v1.constructor && v1.call && v1.apply) {
-					v1 = v1();
-				}
-
-				if (v2.constructor && v2.call && v2.apply) {
-					v2 = v2();
-				}
-
-				return v1 < v2 ? -1 : v1 > v2 ? 1 : 0;
-			};
-		} else {
-			let propArr: string[] = property;
-			if (typeof property === 'string' || property instanceof String) {
-				propArr = <any>[property];
-			}
-
-			return function (a, b) {
-				for (let i = 0, len = propArr.length; i < len; i++) {
-					let currProp = propArr[i];
-					let sortOrder = 1;
-					if (currProp[0] === '-') {
-						sortOrder = -1;
-						currProp = currProp.substr(1);
-					}
-
-					let aVal = a[currProp];
-					let bVal = b[currProp];
-					if (aVal.constructor && aVal.call && aVal.apply) {
-						aVal = aVal();
-					}
-
-					if (bVal.constructor && bVal.call && bVal.apply) {
-						bVal = bVal();
-					}
-
-					const result = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
-					if (result != 0) {
-						return result * sortOrder;
-					}
-				}
-
-				return 0;
-			};
-		}
-	}
-
-	arr.sort(dynamicSort(propName));
-	return arr;
-}

package/common/utils/capitalize-string.ts

@@ -1,11 +0,0 @@
-export function capitalize(str: string): string {
-	if (str != null) {
-		if (str.length > 1) {
-			return str.charAt(0).toUpperCase() + str.slice(1);
-		} else {
-			return str.toUpperCase();
-		}
-	} else {
-		return null;
-	}
-};

package/common/utils/format-string.ts

@@ -1,14 +0,0 @@
-export function formatString(str: string, ...args: any[]): string {
-	return str.replace(/\{\{|\}\}|\{(\d+)\}/g, (m, n) => {
-		if (m == '{{') {
-			return '{';
-		}
-
-		if (m == '}}') {
-			return '}';
-		}
-
-		const index = parseInt(n);
-		return args[index] ?? '';
-	});
-};

package/common/utils/latinize-string.ts

@@ -1,7 +0,0 @@
-export function latinize(str: string): string {
-	try {
-		return (str).normalize('NFD').replace(/[\u0300-\u036F]/g, '');
-	} catch (e) {
-		return str as any;
-	}
-};