@colijnit/corecomponents_v12 254.1.5 → 254.1.7

package/projects/corecomponents/src/lib/core/utils/array-utils.ts

@@ -1,301 +0,0 @@
-import {isNill} from "../function/is-nill.function";
-import {notNill} from "../function/not-nill.function";
-import {StringUtils} from "./string-utils";
-import {NumberUtils} from "./number-utils";
-import {ObjectUtils} from "./object-utils";
-
-export class ArrayUtils {
-    /**
-     * Inserts given element into given array, on given index number.
-     *
-     * @param index The index position for the element to insert, use negatives to count from the arrays end
-     * @param element The element to insert
-     * @param array The array to insert the element into
-     * @returns True if and only if given element is succesfully inserted into given array.
-     */
-    public static InsertElement<T>(index: number, element: T, array: T[]): boolean {
-        if (!Array.isArray(array) || Math.abs(index) > array.length || isNill(index)) {
-            // cannot insert something into nothing, and cannot insert an element into a non-array (via this contract that is), and
-            // we will not insert anything beyond the arrays limits (but we can append to the start or end)
-            return false;
-        }
-
-        const lenBefore: number = array.length;
-        array.splice(index, 0, element);
-        return (array.length === lenBefore + 1);
-    }
-
-    /**
-     * Removes given element from given array. Doesn't just set it to null like JavaScripts standard 'delete' keyword, but truly removes the
-     * element using splice(). Also works on associative arrays.
-     *
-     * @param element The element to remove.
-     * @param array The array to remove the element from.
-     * @returns True iff given element was truly successfully removed from given array.
-     */
-    public static RemoveElement<T>(element: T, array: T[]): boolean {
-        if (!Array.isArray(array)) {
-            return false;
-        }
-
-        let index: number = array.indexOf(element);
-        return ArrayUtils.RemoveElementAtIndex(index, array);
-    }
-
-    /**
-     * Returns a true shallow clone of given array plus all its items. Its first-level members are object-shallow-cloned (optionally with a
-     * strongly typed constructor),
-     * or just as plain object (see param arrayItemsClass).
-     * @param arrayGiven
-     * @param arrayItemsClass If provided, the cloned array's first-level items will be strongly typed to / constructed as this class. Otherwise
-     * it'll be a plain object.
-     * @returns a true shallow clone of given array plus all its items
-     */
-    public static ShallowCloneArrayAndItsItem<T>(arrayGiven: T[], arrayItemsClass?: any): T[] {
-        let arrayClone: T[] = [];
-
-        if (arrayGiven) {
-            for (let i: number = 0, len: number = arrayGiven.length; i < len; i++) {
-                arrayClone.push(ObjectUtils.GetShallowClone(arrayGiven[i], arrayItemsClass));
-            }
-        } else {
-            return [];
-        }
-
-        return arrayClone;
-    }
-
-    /**
-     * Moves given element to given toIndex in given array. Returns whether the element was really moved, thus changing the given array.
-     */
-    public static MoveElement<T>(element: T, toIndex: number, array: T[]): boolean {
-        if (!Array.isArray(array) || isNill(toIndex)) {
-            return false;
-        }
-
-        let fromIndex: number = array.indexOf(element);
-        let toIndexCorrected: number = NumberUtils.GetNearestNumberWithinBounds(toIndex, 0, array.length - 1);
-        if (fromIndex === -1 || array[toIndexCorrected] === element) {
-            // element did not exist in given array, or already existed on given toIndex
-            return false;
-        }
-        array.splice(toIndexCorrected, 0, array.splice(fromIndex, 1)[0]);
-        return true;
-    }
-
-    /**
-     * Returns max value from all resulting values from applying given itemValueFunction to all items of given array.
-     * @param array
-     * @param itemValueFunction The function aplied to each array item that gives it a numerical value. The max num val found is returned.
-     */
-    public static GetMaxCalculatedValue<T>(array: T[], itemValueFunction: (item: T) => number): number {
-        if (!array || !itemValueFunction) {
-            return NaN;
-        }
-
-        let max: number = undefined;
-
-        let len: number = array.length;
-        for (let i: number = 0; i < len; i++) {
-            let valueCur: number = itemValueFunction.call(this);
-            if (valueCur > max) {
-                max = valueCur;
-            }
-        }
-
-        return max;
-    }
-
-    // Checks if given array is defined, and is an array, and has length > 0, and, optionally checks that the first element is of type given clazz.
-    public static IsArrayWithElements<T>(arrayToCheck: T[], clazz?: any): boolean {
-        if (isNill(arrayToCheck)) {
-            return false;
-        }
-
-        if (Array.isArray(arrayToCheck) && arrayToCheck.length > 0) {
-            if (clazz) {
-                return arrayToCheck[0] instanceof clazz;
-            }
-            return true;
-        }
-        return false;
-    }
-
-    // Removes all elements from given array for which given filter function holds true. Returns true if at least one removed, else false.
-    public static RemoveElementsByFilter(array: any[], filterFunction: (item: any) => boolean): boolean {
-        if (!ArrayUtils.IsArrayWithElements(array) || !filterFunction) {
-            return false;
-        }
-
-        let atLeastOneRemoved: boolean = false;
-
-        let len: number = array.length;
-        for (let i: number = len - 1; i >= 0; i--) {
-            let item: any = array[i];
-            if (filterFunction.call(this, item) === true) {
-                array.splice(i, 1);
-                atLeastOneRemoved = true;
-            }
-        }
-
-        return atLeastOneRemoved;
-    }
-
-    // Replaces the elementOut with given elementIn.
-    public static ReplaceElement<T>(elementIn: T, elementOut: T, array: T[]): void {
-        if (!array || !Array.isArray(array)) {
-            return;
-        }
-
-        const indexOut: number = array.indexOf(elementOut);
-        if (indexOut > -1) {
-            ArrayUtils.InsertElement(indexOut, elementIn, array);
-            ArrayUtils.RemoveElement(elementOut, array);
-        }
-    }
-
-    // Swaps the elements in given array with each other. Returns whether a real swap was made. From and To elements have to exist in array.
-    public static SwapElements<T>(elementOne: T, elementTwo: T, array: T[]): boolean {
-        if (!Array.isArray(array)) {
-            return false;
-        }
-
-        const elOneIdx: number = array.indexOf(elementTwo);
-        const elTwoIdx: number = array.indexOf(elementOne);
-        if (elOneIdx === -1 || elTwoIdx === -1) {
-            return false;
-        }
-
-        array[elOneIdx] = array.splice(elTwoIdx, 1, array[elOneIdx])[0];
-        return true;
-    }
-
-    // Inserts or removes given toggle element into given elements array; inserts if not yet exists, and removes if already exists.
-    public static ToggleElement<T>(toggle: T, elements: T[]): void {
-        elements.indexOf(toggle) > -1 ? ArrayUtils.RemoveElement(toggle, elements) : elements.push(toggle);
-    }
-
-    // Returns the number of elements from given array for which given whereFunction holds true.
-    public static CountWhere<T>(array: T[], whereFunction: (item: T) => boolean): number {
-        if (!ArrayUtils.IsArrayWithElements(array) || !whereFunction) {
-            return 0;
-        }
-
-        let count: number = 0;
-
-        const len: number = array.length;
-        for (let i: number = 0; i < len; i++) {
-            if (whereFunction.call(this, array[i])) {
-                count++;
-            }
-        }
-
-        return count;
-    }
-
-    /**
-     * Returns whether at least one element in given array could be found by given finder function.
-     *
-     * @param array
-     * @param finder A finder function that takes an element of the array and returns a boolean that represents
-     * the 'found status' for that element; whether it should have been found or not.
-     */
-    public static ContainsAnElementFoundBy<T>(array: T[], finder: (element: T) => boolean): boolean {
-        if (!array || !finder) {
-            return false;
-        }
-
-        return notNill(ArrayUtils.Find<T>(array, finder));
-    }
-
-    /**
-     * Cross-browser Array.find() function. Returns the first item in given array for which the foundBy function returns true. Returns
-     * undefined when none was found.
-     *
-     * Example usage:
-     * let foundItem: BusinessObject = ArrayUtils.Find<BusinessObject>(modelArray, (modelItem: BusinessObject) => <br>
-     *     (return modelItem.getId() === '1')
-     *   * });
-     *
-     * @param array The array with items to search in.
-     * @param foundBy The finder function applied on each items of the array, when that returns true, the item is considered found.
-     */
-    public static Find<T>(array: T[], foundBy: (item: T) => boolean): T {
-        if (!array || !foundBy) {
-            return undefined;
-        }
-
-        for (let i: number = 0, len: number = array.length; i < len; i++) {
-            let itemCur: T = array[i];
-            if (foundBy(itemCur)) {
-                return itemCur;
-            }
-        }
-        return undefined;
-    }
-
-    /**
-     * Sorts all items in the given array alphabetically (A-to-Z) according to the values of their given property.
-     * @param theArray
-     * @param propertyName = undefined] When not defined, assumes an array of STRINGS is given, instead of array of OBJECTS.
-     * @param [reverseOrder = false] Set to true to sort from Z-to-A instead
-     */
-    public static SortAlphabetically<T>(theArray: T[], propertyName: string = undefined, reverseOrder: boolean = false): void {
-        if (!theArray || !Array.isArray(theArray)) {
-            return;
-        }
-
-        let switcher: number = reverseOrder ? -1 : 1;
-        let stringSort: boolean = StringUtils.IsStringWithLength(propertyName);
-        theArray.sort((itemOne: T, itemTwo: T) => {
-            let valOne: any = stringSort ? itemOne[propertyName] : itemOne;
-            let valTwo: any = stringSort ? itemTwo[propertyName] : itemTwo;
-            return (valOne > valTwo ? 1 : (valOne < valTwo ? -1 : 0)) * switcher;
-        });
-    }
-
-    public static PushIfNotExist(item: any, array: any[]): boolean {
-        if (!array) {
-            return false;
-        }
-
-        if (array.indexOf(item) === -1) {
-            array.push(item);
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * Removes element at given index from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really
-     * removes the element using splice().
-     *
-     * @param index
-     * @param array
-     * @returns True if and only if the element on given index is succesfully removed from given array.
-     */
-    public static RemoveElementAtIndex(index: number, array: any[]): boolean {
-        if (NumberUtils.IsNaN(index) || index < 0 || !Array.isArray(array) || array.length === 0) {
-            return false;
-        }
-
-        if (index in array) {
-            array.splice(index, 1);
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    // Returns true if and only if given array includes given item. Checked by ===.
-    public static Includes(array: any[], item: any): boolean {
-        if (Array.isArray(array)) {
-            for (let i: number = 0, len: number = array.length; i < len; i++) {
-                if (array[i] === item) {
-                    return true;
-                }
-            }
-            return false;
-        }
-    }
-}

package/projects/corecomponents/src/lib/core/utils/browser-utils.ts

@@ -1,123 +0,0 @@
-import { ElementRef } from '@angular/core';
-import { ElementPosition } from '../model/element-position';
-
-export class BrowserUtils {
-    public static ScrollToTop(nativeElement: any, milliSeconds: number = 200): void {
-        return BrowserUtils._ScrollTo("scrollTop", nativeElement, milliSeconds, 0);
-    }
-
-    public static DownloadFile(encodedUri: string, fileType: string): void {
-        const link: HTMLAnchorElement = document.createElement("a");
-        const date: string = new Date().toDateString();
-
-        link.href = encodedUri;
-        link.target = '_blank';
-        link.download = "export_" + date + fileType;
-
-        document.body.appendChild(link);
-        link.click();
-        document.body.removeChild(link);
-    }
-
-    public static CopyToClipboard(data: string): void {
-
-        const textArea: any = document.createElement("TEXTAREA");
-        const textNode: any = document.createTextNode(data);
-
-        textArea.appendChild(textNode);
-        document.body.appendChild(textArea); // Required for FF
-        textArea.select();
-        document.execCommand("copy");
-        document.body.removeChild(textArea);
-    }
-
-    public static TabFocusNextElement(): void {
-        const nextTabStop: any = BrowserUtils._FindNextTabStop(document.activeElement);
-        if (nextTabStop) {
-            nextTabStop.focus();
-        }
-    }
-
-    public static AreDimensionsInView(dimensions: ElementPosition, view?: ElementRef): boolean {
-        const vp: ElementPosition = BrowserUtils.GetDimensions(view);
-
-        return dimensions.top >= vp.top && dimensions.left >= vp.left && dimensions.bottom <= vp.bottom && dimensions.right <= vp.right;
-    }
-
-    public static HorizontalFitInView(dimensions: ElementPosition, view?: ElementRef): boolean {
-        const vp: ElementPosition = BrowserUtils.GetDimensions(view);
-
-        return dimensions.left >= vp.left && dimensions.right <= vp.right;
-    }
-
-    public static VerticalFitInView(dimensions: ElementPosition, view?: ElementRef): boolean {
-        const vp: ElementPosition = BrowserUtils.GetDimensions(view);
-
-        return dimensions.top >= vp.top && dimensions.bottom <= vp.bottom;
-    }
-
-    public static GetViewport(): ElementPosition {
-
-        let viewPortWidth: number;
-        let viewPortHeight: number;
-
-        // the more standards compliant browsers (mozilla/netscape/opera/IE7) use window.innerWidth and window.innerHeight
-        if (typeof window.innerWidth !== 'undefined') {
-            viewPortWidth = window.innerWidth;
-            viewPortHeight = window.innerHeight;
-        } else if (typeof document.documentElement !== 'undefined' &&
-            typeof document.documentElement.clientWidth !== 'undefined' &&
-            document.documentElement.clientWidth !== 0) {
-            viewPortWidth = document.documentElement.clientWidth;
-            viewPortHeight = document.documentElement.clientHeight;
-        } else {
-            viewPortWidth = document.getElementsByTagName('body')[0].clientWidth;
-            viewPortHeight = document.getElementsByTagName('body')[0].clientHeight;
-        }
-
-        return {left: 0, top: 0, right: viewPortWidth, bottom: viewPortHeight};
-    }
-
-    public static GetDimensions(view?: ElementRef): ElementPosition {
-        if (!view) {
-            return this.GetViewport();
-        } else {
-            const elem: HTMLElement = view instanceof HTMLElement ? view : view.nativeElement;
-            const cr: ClientRect = elem.getBoundingClientRect();
-            return {left: cr.left, top: cr.top, right: cr.right, bottom: cr.bottom};
-        }
-    }
-
-    // Recursive.
-    private static _ScrollTo(elementScrollProp: string, element: any, milliSeconds: number, toScrollEnd: number): void {
-        if (!element || milliSeconds <= 0) {
-            return;
-        }
-
-        const difference: number = toScrollEnd - element[elementScrollProp];
-        const scrollPerTick: number = difference / milliSeconds * 10;
-
-        setTimeout(() => {
-            element[elementScrollProp] = element[elementScrollProp] + scrollPerTick;
-            if (element[elementScrollProp] === toScrollEnd) {
-                return;
-            }
-            BrowserUtils._ScrollTo(elementScrollProp, element, milliSeconds - 10, toScrollEnd);
-        }, 10);
-    }
-
-    private static _FindNextTabStop(element: Element): Element {
-        const tabStopElements: NodeListOf<Element> = document.querySelectorAll(
-            'a[href], area[href], input:not(.hidden):not(.disabled):not(.readonly):not(.read-only), select:not(.hidden):not(.disabled):not(.readonly):not(.read-only), textarea:not(.hidden):not(.disabled):not(.readonly):not(.read-only), button:not(.hidden):not(.disabled):not(.readonly):not(.read-only), iframe, object, embed, *[tabindex]:not(.hidden):not(.disabled):not(.readonly):not(.read-only), *[contenteditable]:not(.hidden):not(.disabled):not(.readonly):not(.read-only)'
-        );
-        const actualStopEls: Element[] = [];
-        for (let i: number = 0, len: number = tabStopElements.length; i < len; i++) {
-            const tabEl: any = tabStopElements[i];
-            if (tabEl.tabIndex >= 0) {
-                actualStopEls.push(tabEl);
-            }
-        }
-        const elIdx: number = actualStopEls.indexOf(element);
-        return actualStopEls[elIdx + 1] || undefined;
-    }
-}

package/projects/corecomponents/src/lib/core/utils/business-object-utils.ts

@@ -1,42 +0,0 @@
-/**
- * For this core components project, a business object is just a plain JS object with a given "id property". That is different from iOneJS, where all business objects
- * extend the common BusinessObject class.
- */
-export class BusinessObjectUtils {
-
-    // Returns the first model item in given modelArray, for which it holds that item[idProp] === given idValue. Returns undefined if not found.
-    public static FindItemById<T>(modelArray: T[], idValue: any, idProp: string): T {
-        if (!modelArray) {
-            return undefined;
-        }
-
-        let foundModel: T = undefined;
-
-        const len: number = modelArray.length;
-        for (let i: number = 0; i < len; i++) {
-            const item: T = modelArray[i];
-            if (item && item[idProp] === idValue) {
-                foundModel = item;
-                break;
-            }
-        }
-
-        return foundModel;
-    }
-
-    /**
-     * Returns whether the two given objects are equal. Checks for equal class names and equal id values, or otherwise just whether ref a === b.
-     * @param objectA
-     * @param objectB
-     * @param idProp The name of the id property on both business objects
-     */
-    public static AreEqual(objectA: any, objectB: any, idProp: string): boolean {
-        if (!objectA && !objectB) {
-            return true;
-        } else if (!objectA || !objectB) {
-            return false;
-        } else {
-            return objectA === objectB || objectA[idProp] === objectB[idProp];
-        }
-    }
-}