@colijnit/sharedcomponents 1.0.54 → 1.0.56

package/projects/sharedcomponents/src/lib/utils/array-utils.ts

@@ -0,0 +1,225 @@
+import {ObjectUtils} from "./object-utils";
+import {NumberUtils} from "./number-utils";
+import {isNill} from "./is-nill.function";
+import {notNill} from "./function/not-nill.function";
+
+export class ArrayUtils {
+    /**
+     * Returns whether at least one element in given array could be found by given finder function.
+     *
+     * @param {T[]} array
+     * @param {(element: T) => boolean} 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(this.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:
+     * const 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++) {
+            const itemCur: T = array[i];
+            if (foundBy(itemCur) ) {
+                return itemCur;
+            }
+        }
+        return undefined;
+    }
+
+    // @returns empty array when nothing found, otherwise array with found items
+    public static FindAll<T>(array: T[], foundBy: (item: T) => boolean): T[] {
+        const answer: T[] = [];
+        if (!array || !foundBy) {
+            return answer;
+        }
+
+        for (let i: number = 0, len: number = array.length; i < len; i++) {
+            const itemCur: T = array[i];
+            if (foundBy(itemCur)) {
+                answer.push(itemCur);
+            }
+        }
+        return answer;
+    }
+
+    // returns a simple clone of given array, using array.slice(0)
+    public static CloneArray<T>(array: T[]): T[] {
+        let answer: T[] = [];
+
+        if (array) {
+            answer = array.slice(0);
+        }
+
+        return answer;
+    }
+
+    /**
+     * Returns a 'semi deep clone' of given array. Its first-level members are object-shallow-cloned (optionally with a strongly typed constructor),
+     * or just as plain object (see param arrayItemsClass).
+     * @param array
+     * @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.
+     * @param deepClone Set to true if array items contain FUNCTIONS that need to be cloned..
+     * @returns {Array} semi-deep clone of given array
+     */
+    public static CloneArrayAndItsItems<T>(array: T[], arrayItemsClass?: any, deepClone: boolean = false): T[] {
+        const cloneArray: T[] = [];
+
+        if (array) {
+            for (let i: number = 0, len: number = array.length; i < len; i++) {
+                if (deepClone) {
+                    cloneArray.push(ObjectUtils.GetDeepClone(array[i]));
+                } else {
+                    cloneArray.push(ObjectUtils.GetShallowClone(array[i], arrayItemsClass));
+                }
+            }
+        } else {
+            return [];
+        }
+
+        return cloneArray;
+    }
+
+    /**
+     * 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 {number} index
+     * @param {any[]} array in-out
+     * @returns {boolean} 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;
+        }
+    }
+
+    /**
+     * Removes given element from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really removes the
+     * element using splice(). Also works on associative arrays.
+     *
+     * @param {T} element The element to remove.
+     * @param {T[]} array The array to remove the element from.
+     * @returns {boolean} 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;
+        }
+
+        const index: number = array.indexOf(element);
+        return ArrayUtils.RemoveElementAtIndex(index, array);
+    }
+
+    // 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[], classItemsMustBeInstanceOf?: any): boolean {
+        if (isNill(arrayToCheck)) {
+            return false;
+        }
+
+        if (Array.isArray(arrayToCheck) && arrayToCheck.length > 0) {
+            if (classItemsMustBeInstanceOf) {
+                return arrayToCheck[0] instanceof classItemsMustBeInstanceOf;
+            } else {
+                return true;
+            }
+        } else {
+            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;
+
+        const len: number = array.length;
+        for (let i: number = len - 1; i >= 0; i--) {
+            const item: any = array[i];
+            if (filterFunction.call(this, item) === true) {
+                array.splice(i, 1);
+                atLeastOneRemoved = true;
+            }
+        }
+
+        return atLeastOneRemoved;
+    }
+
+    public static MoveElement<T>(element: T, toIndex: number, array: T[]): boolean {
+        if (!Array.isArray(array) || isNill(toIndex)) {
+            return false;
+        }
+
+        const fromIndex: number = array.indexOf(element);
+        const 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;
+    }
+
+    // PRE: elements exists in given array. POST: given elementToPlace has a lower index than given afterThisElement. Array is in-out manipulated.
+    public static PlaceElementAfterOther(array: any[], elementToPlace: any, afterThisElement: any): void {
+        if (array) {
+            const afterThisElIdx: number = array.indexOf(afterThisElement);
+            const elToPlaceIdx: number = array.indexOf(elementToPlace);
+            if (afterThisElIdx >= elToPlaceIdx) {
+                ArrayUtils.MoveElement(elementToPlace, afterThisElIdx + 1, array);
+            }
+        }
+    }
+
+  /**
+   * Returns max value from all resulting values from applying given itemValueFunction to all items of given array.
+   * @param array
+   * @param itemValueFunction The function applied 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;
+
+    const len: number = array.length;
+    for (let i: number = 0; i < len; i++) {
+      const valueCur: number = itemValueFunction.call(this);
+      if (valueCur > max) {
+        max = valueCur;
+      }
+    }
+
+    return max;
+  }
+}

package/projects/sharedcomponents/src/lib/utils/calendar.utils.ts

@@ -0,0 +1,75 @@
+import {DateUtils} from "./date-utils";
+import {Weekday} from "../model/weekday.model";
+import {Inject, LOCALE_ID} from "@angular/core";
+import {LanguageCode} from "../enum/language-code.enum";
+import {Week} from "../model/week.model";
+
+export class CalendarUtils {
+    public static Locale: LanguageCode = undefined;
+
+    public static Now: Date = new Date();
+
+    constructor(
+        @Inject(LOCALE_ID) private readonly _locale: LanguageCode
+    ) {
+        CalendarUtils.Locale = _locale;
+    }
+
+    // public static GetCurrentYear(): number {
+    //     return this.Now.getFullYear();
+    // }
+    //
+    // public static GetCurrentMonth(): number {
+    //     return this.Now.getUTCMonth() + 1;
+    // }
+
+    public static GetDayHours(day: Date): Date[] {
+        const datesByTheHour: Date[] = [];
+        if (day) {
+            let newDate: Date = new Date(day);
+            newDate.setHours(0, 0, 0, 0);
+            datesByTheHour.push(newDate);
+            for (let i: number = 0; i < 23; i++) {
+                newDate = new Date(newDate);
+                newDate.setHours(newDate.getHours() + 1);
+                datesByTheHour.push(newDate);
+            }
+        }
+        return datesByTheHour;
+    }
+
+    public static GetDaysOfWeek(date: Date): Week {
+        let day = new Date();
+        const daysOfWeek: Weekday[] = [];
+        let options: any;
+        let month: number;
+        for (let i: number = 0; i < 3; i++) {
+            const dayPerWeek: Weekday = new Weekday();
+            const dayHours: Date[] = CalendarUtils.GetDayHours(day);
+            dayPerWeek.newMonth = day.getMonth() !== month;
+            dayPerWeek.weekdaySelected = day.getDay() === date.getDay();
+            dayPerWeek.weekdayDay = day.getDate();
+            options = { weekday: "short" };
+            dayPerWeek.weekdayShort = day.toLocaleDateString(CalendarUtils.Locale, options);
+            options = { weekday: "long" };
+            dayPerWeek.weekdayLong = day.toLocaleDateString(CalendarUtils.Locale, options);
+
+            options = { month: "short" };
+            dayPerWeek.weekdayMonthShort = day.toLocaleDateString(CalendarUtils.Locale, options);
+            options = { month: "long" };
+            dayPerWeek.weekdayMonthLong = day.toLocaleDateString(CalendarUtils.Locale, options);
+            dayPerWeek.weekdayYear = day.getFullYear();
+
+            dayPerWeek.date = new Date(day);
+            dayPerWeek.datesByTheHour = dayHours;
+            daysOfWeek.push(dayPerWeek);
+            month = day.getMonth();
+            day = new Date(day);
+            day.setDate(day.getDate() + 1);
+        }
+        const week: Week = new Week();
+        week.weekDays = daysOfWeek;
+        return week;
+    }
+
+}

package/projects/sharedcomponents/src/lib/utils/check-precision-and-scale-result.ts

@@ -0,0 +1,5 @@
+// Output object shape for NumberUtils.CheckPrecisionAndScale().
+export interface CheckPrecisionAndScaleResult {
+    isOk: boolean;
+    nearestOkNr?: number;
+}

package/projects/sharedcomponents/src/lib/utils/check-within-stepped-bounds-result.ts

@@ -0,0 +1,8 @@
+/**
+ * Output object shape for NumberUtils.CheckWithinSteppedBounds(). For efficiency, this method also returns the found remainder if the given
+ * number was NOT within the specified stepped bounds.
+ */
+export interface CheckWithinSteppedBoundsResult {
+    isOk: boolean;
+    remainder?: number;
+}

package/projects/sharedcomponents/src/lib/utils/css-utils.ts

@@ -0,0 +1,275 @@
+import {NumberUtils} from "./number-utils";
+
+// Static utility functions holder related to CSS.
+export class CssUtils {
+
+    /**
+     * Performs a horizontal size change animation on the given DOM element.
+     *
+     * @param {any} nativeElement The DOM element
+     * @param {number} transitionTime In seconds
+     * @param {string} startWidth Pixel size string
+     * @param {string} endWidth Defaults to elements true width, by calculation
+     * @returns {Promise<any>} A resolved promise after the transition was done.
+     */
+    public static AnimateMaxWidthTransitionOn(
+        nativeElement: any,
+        transitionTime: number = 0.2,
+        startWidth: string = "0px",
+        endWidth?: string
+    ): Promise<void> {
+        if (!nativeElement) {
+            return;
+        }
+
+        if (!endWidth) {
+            endWidth = CssUtils.FindOffsetWidthOfElementWithTransition(nativeElement);
+        }
+        const transitionStyle: string = `max-width ${transitionTime}s ease-out`;
+        if (!CssUtils.ElementHasStyle(nativeElement, "transition", transitionStyle)) {
+            CssUtils._AddTransitionStyleOn(nativeElement, transitionStyle);
+        }
+        nativeElement.style.maxWidth = startWidth;
+        CssUtils.PushCssChanges(nativeElement);
+        nativeElement.style.maxWidth = endWidth;
+
+        return this._returnPromise(transitionTime);
+
+    }
+
+    /**
+     * Performs a vertical size change animation on the given DOM element.
+     *
+     * @param {any} nativeElement The DOM element
+     * @param {number} transitionTime In seconds
+     * @param {string} startHeight Pixel size string
+     * @param {string} endHeight Defaults to elements true height, by calculation
+     * @returns {Promise<any>} A resolved promise after the transition was done.
+     */
+    public static AnimateMaxHeightTransitionOn(
+        nativeElement: any,
+        transitionTime: number = 0.2,
+        startHeight: string = "0px",
+        endHeight?: string
+    ): Promise<void> {
+        if (!nativeElement) {
+            return;
+        }
+
+        if (!endHeight) {
+            endHeight = CssUtils.FindOffsetHeightOfElementWithTransition(nativeElement);
+        }
+        const transitionStyle: string = `max-height ${transitionTime}s ease-out`;
+        if (!CssUtils.ElementHasStyle(nativeElement, "transition", transitionStyle)) {
+            CssUtils._AddTransitionStyleOn(nativeElement, transitionStyle);
+        }
+        nativeElement.style.maxHeight = startHeight;
+        CssUtils.PushCssChanges(nativeElement);
+        nativeElement.style.maxHeight = endHeight;
+
+        return this._returnPromise(transitionTime);
+    }
+
+    public static AnimateMaxWidthToZeroOn(nativeElement: any, transitionTime: number = 0.2): Promise<any> {
+        return CssUtils.AnimateMaxWidthTransitionOn(nativeElement, transitionTime, CssUtils.GetTrueWidthOf(nativeElement) + "px", "0px");
+    }
+
+    public static AnimateMaxHeightToZeroOn(nativeElement: any, transitionTime: number = 0.2): Promise<any> {
+        return CssUtils.AnimateMaxHeightTransitionOn(nativeElement, transitionTime, CssUtils.GetTrueHeightOf(nativeElement) + "px", "0px");
+    }
+
+    /**
+     * Returns the offsetwidth of given element as a pixel string. Uses trick to find true width of elements with a max-width of 0 and
+     * that have a transition style applied.
+     *
+     * @param {any} nativeElement The DOM element
+     * @returns {string} The width in pixels, e.g. "20px"
+     */
+    public static FindOffsetWidthOfElementWithTransition(nativeElement: any): string {
+        return this._FindOffsetHeightOrWidthOfElementWithTransition(nativeElement, false);
+    }
+
+    /**
+     * Returns the offsetheight of given element as a pixel string. Uses trick to find true width of elements with a max-height of 0 and
+     * that have a transition style applied.
+     *
+     * @param {any} nativeElement The DOM element
+     * @returns {string} The height in pixels, e.g. "20px"
+     */
+    public static FindOffsetHeightOfElementWithTransition(nativeElement: any): string {
+        return this._FindOffsetHeightOrWidthOfElementWithTransition(nativeElement, true);
+    }
+
+    // Returns the true height of the given element, in NUMBER of pixels. Includes margins.
+    public static GetTrueHeightOf(nativeElement: any): number {
+        const heightMargins: number = NumberUtils.ParseInt(document.defaultView.getComputedStyle(nativeElement, "").getPropertyValue("margin-top"))
+            + NumberUtils.ParseInt(document.defaultView.getComputedStyle(nativeElement, "").getPropertyValue("margin-bottom"));
+        return nativeElement.offsetHeight + heightMargins;
+    }
+
+    /**
+     *
+     * @param nativeElement
+     * @param styleName e.g. "margin-top"
+     * @returns {any}
+     */
+    public static GetComputedStyleVal(nativeElement: any, styleName: string): any {
+        return document.defaultView.getComputedStyle(nativeElement, "").getPropertyValue("styleName");
+    }
+
+    // Returns the true width of the given element, in NUMBER of pixels. Includes margins.
+    public static GetTrueWidthOf(nativeElement: any): number {
+        const widthMargins: number = NumberUtils.ParseInt(document.defaultView.getComputedStyle(nativeElement, "").getPropertyValue("margin-left"))
+            + NumberUtils.ParseInt(document.defaultView.getComputedStyle(nativeElement, "").getPropertyValue("margin-right"));
+        return nativeElement.offsetWidth + widthMargins;
+    }
+
+    public static ElementHasStyle(nativeElement: any, styleName: string, styleValue: string): boolean {
+        if (!nativeElement || !styleName) {
+            return false;
+        }
+        return (nativeElement.style[styleName] === styleValue);
+    }
+
+    public static SetStyleOnElement(nativeElement: any, styleName: string, styleValue: string, pushChanges: boolean = false): void {
+        if (!nativeElement || !styleName) {
+            return;
+        }
+
+        nativeElement.style[styleName] = styleValue;
+        if (pushChanges) {
+            CssUtils.PushCssChanges(nativeElement);
+        }
+    }
+
+    public static HideElement(nativeElement: any): void {
+        if (nativeElement) {
+            CssUtils.SetStyleOnElement(nativeElement, "display", "none");
+        }
+    }
+
+    /**
+     * Returns the value of the given CSS style on the given native element.
+     * @param nativeElement
+     * @param styleName
+     * @returns {any}
+     */
+    public static GetStyleValue(nativeElement: any, styleName: string): any {
+        if (!nativeElement || !styleName) {
+            return;
+        }
+
+        return nativeElement.style[styleName];
+    }
+
+    /**
+     * Returns a CSS-usable RGB string representation of given database-returned rgb color string.
+     * Database returns color strings like "0xFFFF00" or "0X0"
+     *
+     * @param dbRgbColorStr e.g. 0x990000, or 0xAB045F
+     * @returns {string} The CSS HEX representation of given color
+     */
+    public static DbRgbColorStringToCssRgbColor(dbRgbColorStr: string): string {
+        if (!dbRgbColorStr || dbRgbColorStr.length === 0) {
+            return undefined;
+        }
+
+        // "0x" should become "#"
+        dbRgbColorStr = dbRgbColorStr.split("0x")[1];
+        if (!dbRgbColorStr) {
+            return undefined;
+        }
+        // database colors could contain errors, like too little or too many color characters: correct them here.
+        const strLen: number = dbRgbColorStr.length;
+        // make sure our length is 6 or 3
+        if (strLen > 6) {
+            dbRgbColorStr = dbRgbColorStr.slice(0, 6);
+        } else if (strLen > 3 && strLen < 6) {
+            dbRgbColorStr = dbRgbColorStr.slice(0, 3);
+        } else if (strLen === 1) {
+            // a strLen of 1 would be more common than 2 (eg black is '0'), so its else clause sits above the == 2 case here
+            dbRgbColorStr += dbRgbColorStr + dbRgbColorStr;
+        } else if (strLen === 2) {
+            dbRgbColorStr += dbRgbColorStr[1];
+        }
+        // the final css-usable color
+        return "#" + dbRgbColorStr;
+    }
+
+    public static PushCssChanges(nativeElement: any): void {
+        /* eslint-disable */
+        // trick to wake renderer and push css changes, do not delete this line due to unused variable!
+        const notUnused: number = nativeElement.offsetHeight; //NOSONAR
+        /* eslint-enable */
+        return;
+    }
+
+    public static TransparentColor(hexColor: string, opacity: number): string {
+        const hex: string = hexColor.replace("#", "");
+        return `rgba(${Array.from({length: 3}, (v, i) =>
+            parseInt(hex.substring(i * 2, (i + 1) * 2), 16)
+        ).join(",")},${opacity})`;
+    }
+
+    public static ElementHasClass(element: Element, cssClass: string): boolean {
+        return element && element.classList && element.classList.contains(cssClass);
+    }
+
+    // @param height True if you want height,fFalse if you want width
+    private static _FindOffsetHeightOrWidthOfElementWithTransition(nativeElement: any, wantHeight: boolean): string {
+        if (!nativeElement) {
+            return "0px";
+        }
+
+        /* Take transition off temporarily to allow element to grow to its true size,
+         then measure that size and reapply transition styling. */
+        const originalTransitionStyle: string = nativeElement.style.transition;
+        CssUtils._AddTransitionStyleOn(nativeElement, "none");
+
+        if (wantHeight) {
+            nativeElement.style.maxHeight = "";
+        } else {
+            nativeElement.style.maxWidth = "";
+        }
+
+        let trueHeightOrWidth: string;
+        if (wantHeight) {
+            trueHeightOrWidth = nativeElement.offsetHeight;
+        } else {
+            trueHeightOrWidth = nativeElement.offsetWidth;
+        }
+        trueHeightOrWidth += "px";
+
+        nativeElement.style.transition = originalTransitionStyle;
+
+        return trueHeightOrWidth;
+    }
+
+    /**
+     * Adds given transition style on given DOM element.
+     *
+     * @param {any} nativeElement DOM element reference
+     * @param {string} styleText The shorthand style string for the transition to set
+     */
+    private static _AddTransitionStyleOn(nativeElement: any, styleText: string): void {
+        if (!nativeElement || !styleText) {
+            return;
+        }
+
+        // if it already has a transition style: append new one with a comma
+        if (nativeElement.style.transition) {
+            styleText = ", " + styleText;
+        }
+        nativeElement.style.transition += styleText;
+        nativeElement.style.WebkitTransition += styleText;
+        nativeElement.style.MozTransition += styleText;
+    }
+
+    private static _returnPromise(transitionTime: number): Promise<any> {
+        return new Promise<void>((resolve: Function) => {
+            setTimeout(() => {
+                resolve();
+            }, transitionTime * 1000);
+        });
+    }
+}