@colijnit/sharedcomponents 1.0.56 → 1.0.58

package/esm2015/lib/utils/date-utils.js

@@ -0,0 +1,264 @@
+import { ALL_MONTHS } from "../model/constant/all-months";
+import { notNill } from "./function/not-nill.function";
+import * as moment from "moment";
+import { DatePipe } from "@angular/common";
+import { DateRange } from "../model/date-range";
+Date.prototype.toJSON = function () {
+    return moment(this).format('YYYY-MM-DD[T]HH:mm:ss');
+};
+// static utility function holder related to dates
+export class DateUtils {
+    static NowAsString() {
+        return DateUtils.ParseDate(new Date(), DateUtils.BACKEND_DATE_FORMAT);
+    }
+    static ParseDate(date, format = "d-m-y") {
+        if (!date) {
+            return "";
+        }
+        const day = ("0" + date.getDate()).slice(-2);
+        const month = ("0" + (date.getMonth() + 1)).slice(-2);
+        const year = date.getFullYear() + "";
+        const formatParts = format.split("-");
+        const dateParts = [];
+        for (let i = 0, l = formatParts.length; i < l; i++) {
+            switch (formatParts[i]) {
+                case "d":
+                case "DD":
+                    dateParts.push(day);
+                    break;
+                case "m":
+                case "MM":
+                    dateParts.push(month);
+                    break;
+                case "y":
+                case "YYYY":
+                    dateParts.push(year);
+                    break;
+                default:
+                    break;
+            }
+        }
+        return dateParts.join("-");
+    }
+    static GetWeekNumber(date) {
+        date = new Date(date.getTime());
+        date.setHours(0, 0, 0, 0);
+        date.setDate(date.getDate() + 4 - (date.getDay() || 7));
+        return Math.ceil((((date.getTime() - new Date(date.getFullYear(), 0, 1).getTime()) / 8.64e7) + 1) / 7);
+    }
+    // Returns the number of days from now, for the given date in the future. Returns negative days if given date is in the past from now.
+    static GetDaysFromNow(date) {
+        return DateUtils.GetDayDifference(new Date(Date.now()), date);
+    }
+    static StringAsDate(str, format = DateUtils.BACKEND_DATE_FORMAT) {
+        if (notNill(str)) {
+            if (!isNaN(Number(str))) {
+                return new Date(str);
+            }
+            else {
+                const time = moment(str, format, true);
+                return time.isValid() ? new Date(time) : undefined;
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+    static MomentToDate(time) {
+        if (!time || !time.isValid()) {
+            return undefined;
+        }
+        const d = new Date(time.format(DateUtils.BACKEND_DATE_FORMAT));
+        d.setHours(time.hours());
+        d.setMinutes(time.minutes());
+        d.setSeconds(time.seconds());
+        return d;
+    }
+    static GetCurrentMonth() {
+        return ALL_MONTHS[new Date().getMonth()];
+    }
+    // @returns e.g. ["FEBRUARI", "MARCH", ..] if it's Februari today, otherwise e.g. ["APRIL", "MAY", ...] if it's April today
+    static Get12MonthsArrayWithFirstMonthIsCurrentMonth() {
+        const answer = [];
+        let monthNrToAdd = new Date().getMonth();
+        for (let i = 0; i < 12; i++) {
+            answer.push(ALL_MONTHS[monthNrToAdd]);
+            monthNrToAdd = (monthNrToAdd + 1) % ALL_MONTHS.length;
+        }
+        return answer;
+    }
+    static GetFirstDayOfWeek(date) {
+        if (!DateUtils._ValidDate(date)) {
+            return null;
+        }
+        let firstDay;
+        const dayOfWeek = date.getDay() || 7;
+        if (dayOfWeek === 1) {
+            firstDay = new Date(date);
+        }
+        else {
+            firstDay = new Date(date);
+            firstDay.setHours(-24 * (dayOfWeek - 1));
+        }
+        return firstDay;
+    }
+    static GetLastDayOfWeek(date) {
+        const firstDayOfWeek = DateUtils.GetFirstDayOfWeek(date);
+        const lastDayOfWeek = new Date(firstDayOfWeek);
+        lastDayOfWeek.setDate(firstDayOfWeek.getDate() + 6);
+        return lastDayOfWeek;
+    }
+    static GetFirstDayOfMonth(date) {
+        if (!DateUtils._ValidDate(date)) {
+            return null;
+        }
+        const year = date.getFullYear();
+        const month = date.getMonth();
+        return new Date(year, month, 1);
+    }
+    static GetLastDayOfMonth(date) {
+        if (!DateUtils._ValidDate(date)) {
+            return null;
+        }
+        const year = date.getFullYear();
+        const month = date.getMonth();
+        return new Date(year, month + 1, 0);
+    }
+    static DatesEqual(date1, date2) {
+        let result = false;
+        if (DateUtils._ValidDate(date1) && DateUtils._ValidDate(date2)) {
+            result =
+                date1.getDate() === date2.getDate() &&
+                    date1.getMonth() === date2.getMonth() &&
+                    date1.getFullYear() === date2.getFullYear();
+        }
+        return result;
+    }
+    static DateRangeEqual(dates1, dates2) {
+        return (this.DatesEqual(dates1.startDate, dates2.startDate) &&
+            this.DatesEqual(dates1.endDate, dates2.endDate));
+    }
+    static AddMinutes(date, minutes) {
+        return new Date(date.getTime() + (minutes * 60000));
+    }
+    static AddDays(date, days) {
+        const result = new Date(date);
+        result.setDate(result.getDate() + days);
+        return result;
+    }
+    static AddMonths(date, months) {
+        const result = new Date(date);
+        result.setMonth(result.getMonth() + months);
+        return result;
+    }
+    static DetermineDSTBreakpoints() {
+        const endOfYear = new Date(new Date().getFullYear(), 11, 1);
+        let checkDate = new Date(new Date().getFullYear(), 0, 1);
+        let offset = checkDate.getTimezoneOffset();
+        const periodStart = new Date();
+        let periodStartSet = false;
+        const periodEnd = new Date();
+        let periodEndSet = false;
+        while (checkDate.getTime() < endOfYear.getTime()) {
+            checkDate = this.AddMinutes(checkDate, 60);
+            if (offset < checkDate.getTimezoneOffset()) {
+                periodEnd.setTime(checkDate.getTime());
+                periodEndSet = true;
+            }
+            else if (offset > checkDate.getTimezoneOffset()) {
+                periodStart.setTime(checkDate.getTime());
+                periodStartSet = true;
+            }
+            offset = checkDate.getTimezoneOffset();
+            if (periodStartSet && periodEndSet) {
+                break;
+            }
+        }
+        if (periodStartSet && periodEndSet) {
+            return {
+                start: this._DateToTimeStringWithDateFormat(periodStart),
+                end: this._DateToTimeStringWithDateFormat(periodEnd)
+            };
+        }
+        else {
+            return { start: undefined, end: undefined }; // important otherwise we return new Date() for both
+        }
+    }
+    static _ValidDate(date) {
+        return date !== null && date !== undefined;
+    }
+    /**
+     * Returns the difference between the two given days as the number of days, in float precision (date to - date from).
+     * Returns negative values of the 'from' date is later than in time than the 'to' date.
+     */
+    static GetDayDifference(from, to) {
+        if (!from || !to) {
+            return NaN;
+        }
+        return ((to.getTime() - from.getTime()) / 1000 / 60 / 60 / 24);
+    }
+    static IsSameDay(dateOne, dateTwo) {
+        return (dateOne && dateTwo &&
+            dateOne.getDate() === dateTwo.getDate()
+            && dateOne.getMonth() === dateTwo.getMonth()
+            && dateOne.getFullYear() === dateTwo.getFullYear());
+    }
+    static IsInBetween(date, startDate, endDate, withTime = true) {
+        if (startDate && endDate) {
+            if (withTime) {
+                return (date > startDate && date < endDate);
+            }
+            else {
+                const dateWithoutTime = new Date(date).setHours(0, 0, 0, 0), dateFromWithoutTime = new Date(startDate).setHours(0, 0, 0, 0), dateToWithoutTime = new Date(endDate).setHours(0, 0, 0, 0);
+                return dateWithoutTime >= dateFromWithoutTime && dateWithoutTime <= dateToWithoutTime;
+            }
+        }
+    }
+    static IsMonday(date) {
+        return date.getDay() === 1;
+    }
+    static IsSunday(date) {
+        return date.getDay() === 0;
+    }
+    static IsToday(date) {
+        const today = new Date();
+        return DateUtils.IsSameDay(today, date);
+    }
+    // Returns date format like it would when using a pipe in the templete, ie: "1 okt. 2020"
+    static ParseDateInShortDateFormat(date, locale) {
+        this.datePipe = new DatePipe(locale);
+        const parsedDate = this.datePipe.transform(date);
+        return parsedDate;
+    }
+    // Transforms a string that is formatted like "'17-08-2014'<=?<='17-08-2021'" into "'17-08-2014' Untill '17-08-2021'"
+    static getFormattedDateRangeString(dateRangeString, separator = " - ") {
+        let newString = dateRangeString;
+        newString = newString.replace("<=?<=", ` ${separator} `);
+        newString = newString.replace(/'/g, "");
+        return newString;
+    }
+    static SetDateOrDateRangeObjectHoursZero(date) {
+        if (date instanceof DateRange) {
+            if (date.startDate) {
+                date.startDate.setHours(0, 0, 0);
+            }
+            if (date.endDate) {
+                date.endDate.setHours(0, 0, 0);
+            }
+        }
+        else if (!!date && (date instanceof Date)) {
+            date.setHours(0, 0, 0, 0);
+        }
+    }
+    static _DateToTimeStringWithDateFormat(value, dateFormat = "d-m-y") {
+        if (!value) {
+            return "";
+        }
+        const hours = value.getHours() < 10 ? "0" + value.getHours() : "" + value.getHours();
+        const minutes = value.getMinutes() < 10 ? "0" + value.getMinutes() : "" + value.getMinutes();
+        return this.ParseDate(value, dateFormat) + " " + [hours, minutes].join(":");
+    }
+}
+DateUtils.BACKEND_DATE_FORMAT = 'YYYY-MM-DD[T]HH:mm:ss';
+DateUtils.datePipe = new DatePipe('shortDate');
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-utils.js","sourceRoot":"","sources":["../../../../../projects/sharedcomponents/src/lib/utils/date-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {Month} from \"../enum/month.enum\";\r\nimport {ALL_MONTHS} from \"../model/constant/all-months\";\r\nimport {notNill} from \"./function/not-nill.function\";\r\nimport * as moment from \"moment\";\r\nimport {Moment} from \"moment\";\r\nimport {DatePipe} from \"@angular/common\";\r\nimport {DateRange} from \"../model/date-range\";\r\n\r\nDate.prototype.toJSON = function() {\r\n    return moment(this).format('YYYY-MM-DD[T]HH:mm:ss');\r\n}\r\n\r\n// static utility function holder related to dates\r\nexport class DateUtils {\r\n    public static readonly BACKEND_DATE_FORMAT: string = 'YYYY-MM-DD[T]HH:mm:ss';\r\n    public static datePipe: DatePipe = new DatePipe('shortDate');\r\n\r\n    public static NowAsString(): string {\r\n        return DateUtils.ParseDate(new Date(), DateUtils.BACKEND_DATE_FORMAT);\r\n    }\r\n\r\n    public static ParseDate(date: Date, format: string = \"d-m-y\"): string {\r\n        if (!date) {\r\n            return \"\";\r\n        }\r\n\r\n        const day: string = (\"0\" + date.getDate()).slice(-2);\r\n        const month: string = (\"0\" + (date.getMonth() + 1)).slice(-2);\r\n        const year: string = date.getFullYear() + \"\";\r\n\r\n        const formatParts: string[] = format.split(\"-\");\r\n        const dateParts: string[] = [];\r\n\r\n\r\n        for (let i: number = 0, l: number = formatParts.length; i < l; i++) {\r\n            switch (formatParts[i]) {\r\n                case \"d\" :\r\n                case \"DD\" :\r\n                    dateParts.push(day);\r\n                    break;\r\n                case \"m\" :\r\n                case \"MM\" :\r\n                    dateParts.push(month);\r\n                    break;\r\n                case \"y\" :\r\n                case \"YYYY\" :\r\n                    dateParts.push(year);\r\n                    break;\r\n                default:\r\n                    break;\r\n            }\r\n        }\r\n        return dateParts.join(\"-\");\r\n    }\r\n\r\n    public static GetWeekNumber(date: Date): number {\r\n        date = new Date(date.getTime());\r\n        date.setHours(0, 0, 0, 0);\r\n        date.setDate(date.getDate() + 4 - (date.getDay() || 7));\r\n        return Math.ceil((((date.getTime() - new Date(date.getFullYear(), 0, 1).getTime()) / 8.64e7) + 1) / 7);\r\n    }\r\n\r\n    // Returns the number of days from now, for the given date in the future. Returns negative days if given date is in the past from now.\r\n    public static GetDaysFromNow(date: Date): number {\r\n        return DateUtils.GetDayDifference(new Date(Date.now()), date);\r\n    }\r\n\r\n    public static StringAsDate(str: string, format: string = DateUtils.BACKEND_DATE_FORMAT): Date {\r\n        if (notNill(str)) {\r\n            if (!isNaN(Number(str))) {\r\n                return new Date(str);\r\n            } else {\r\n                const time: any = moment(str, format, true);\r\n                return time.isValid() ? new Date(time) : undefined;\r\n            }\r\n        } else {\r\n            return undefined;\r\n        }\r\n    }\r\n\r\n    public static MomentToDate(time: Moment): Date {\r\n        if (!time || !time.isValid()) {\r\n            return undefined;\r\n        }\r\n\r\n        const d: Date = new Date(time.format(DateUtils.BACKEND_DATE_FORMAT));\r\n        d.setHours(time.hours());\r\n        d.setMinutes(time.minutes());\r\n        d.setSeconds(time.seconds());\r\n        return d;\r\n    }\r\n\r\n    public static GetCurrentMonth(): Month {\r\n        return ALL_MONTHS[new Date().getMonth()];\r\n    }\r\n\r\n    // @returns e.g. [\"FEBRUARI\", \"MARCH\", ..] if it's Februari today, otherwise e.g. [\"APRIL\", \"MAY\", ...] if it's April today\r\n    public static Get12MonthsArrayWithFirstMonthIsCurrentMonth(): Month[] {\r\n        const answer: Month[] = [];\r\n\r\n        let monthNrToAdd: number = new Date().getMonth();\r\n        for (let i: number = 0; i < 12; i++) {\r\n            answer.push(ALL_MONTHS[monthNrToAdd]);\r\n            monthNrToAdd = (monthNrToAdd + 1) % ALL_MONTHS.length;\r\n        }\r\n\r\n        return answer;\r\n    }\r\n\r\n    public static GetFirstDayOfWeek(date: Date): Date {\r\n        if (!DateUtils._ValidDate(date)) {\r\n            return null;\r\n        }\r\n        let firstDay: Date;\r\n        const dayOfWeek: number = date.getDay() || 7;\r\n        if (dayOfWeek === 1) {\r\n            firstDay = new Date(date);\r\n        } else {\r\n            firstDay = new Date(date);\r\n            firstDay.setHours(-24 * (dayOfWeek - 1));\r\n        }\r\n        return firstDay;\r\n    }\r\n\r\n    public static GetLastDayOfWeek(date: Date): Date {\r\n        const firstDayOfWeek: Date = DateUtils.GetFirstDayOfWeek(date);\r\n        const lastDayOfWeek: Date = new Date(firstDayOfWeek);\r\n        lastDayOfWeek.setDate(firstDayOfWeek.getDate() + 6);\r\n        return lastDayOfWeek;\r\n    }\r\n\r\n    public static GetFirstDayOfMonth(date: Date): Date {\r\n        if (!DateUtils._ValidDate(date)) {\r\n            return null;\r\n        }\r\n        const year: number = date.getFullYear();\r\n        const month: number = date.getMonth();\r\n        return new Date(year, month, 1);\r\n    }\r\n\r\n    public static GetLastDayOfMonth(date: Date): Date {\r\n        if (!DateUtils._ValidDate(date)) {\r\n            return null;\r\n        }\r\n        const year: number = date.getFullYear();\r\n        const month: number = date.getMonth();\r\n        return new Date(year, month + 1, 0);\r\n    }\r\n\r\n    public static DatesEqual(date1: Date, date2: Date): boolean {\r\n        let result: boolean = false;\r\n        if (DateUtils._ValidDate(date1) && DateUtils._ValidDate(date2)) {\r\n            result =\r\n                date1.getDate() === date2.getDate() &&\r\n                date1.getMonth() === date2.getMonth() &&\r\n                date1.getFullYear() === date2.getFullYear();\r\n        }\r\n        return result;\r\n    }\r\n\r\n    public static DateRangeEqual(dates1: DateRange, dates2: DateRange): boolean {\r\n        return (this.DatesEqual(dates1.startDate, dates2.startDate) &&\r\n            this.DatesEqual(dates1.endDate, dates2.endDate));\r\n    }\r\n\r\n    public static AddMinutes(date: Date, minutes: number): Date {\r\n        return new Date(date.getTime() + (minutes * 60000));\r\n    }\r\n\r\n    public static AddDays(date: Date, days: number): Date {\r\n        const result: Date = new Date(date);\r\n        result.setDate(result.getDate() + days);\r\n        return result;\r\n    }\r\n\r\n    public static AddMonths(date: Date, months: number): Date {\r\n        const result: Date = new Date(date);\r\n        result.setMonth(result.getMonth() + months);\r\n        return result;\r\n    }\r\n\r\n    public static DetermineDSTBreakpoints(): { start: string, end: string } {\r\n        const endOfYear: Date = new Date(new Date().getFullYear(), 11, 1);\r\n        let checkDate: Date = new Date(new Date().getFullYear(), 0, 1);\r\n        let offset: number = checkDate.getTimezoneOffset();\r\n\r\n        const periodStart: Date = new Date();\r\n        let periodStartSet: boolean = false;\r\n        const periodEnd: Date = new Date();\r\n        let periodEndSet: boolean = false;\r\n        while (checkDate.getTime() < endOfYear.getTime()) {\r\n            checkDate = this.AddMinutes(checkDate, 60);\r\n            if (offset < checkDate.getTimezoneOffset()) {\r\n                periodEnd.setTime(checkDate.getTime());\r\n                periodEndSet = true;\r\n            } else if (offset > checkDate.getTimezoneOffset()) {\r\n                periodStart.setTime(checkDate.getTime());\r\n                periodStartSet = true;\r\n            }\r\n            offset = checkDate.getTimezoneOffset();\r\n            if (periodStartSet && periodEndSet) {\r\n                break;\r\n            }\r\n        }\r\n\r\n        if (periodStartSet && periodEndSet) {\r\n            return {\r\n                start: this._DateToTimeStringWithDateFormat(periodStart),\r\n                end: this._DateToTimeStringWithDateFormat(periodEnd)\r\n            };\r\n        } else {\r\n            return {start: undefined, end: undefined}; // important otherwise we return new Date() for both\r\n        }\r\n    }\r\n\r\n    private static _ValidDate(date: Date): boolean {\r\n        return date !== null && date !== undefined;\r\n    }\r\n\r\n    /**\r\n     * Returns the difference between the two given days as the number of days, in float precision (date to - date from).\r\n     * Returns negative values of the 'from' date is later than in time than the 'to' date.\r\n     */\r\n    public static GetDayDifference(from: Date, to: Date): number {\r\n        if (!from || !to) {\r\n            return NaN;\r\n        }\r\n        return ((to.getTime() - from.getTime()) / 1000 / 60 / 60 / 24);\r\n    }\r\n\r\n    public static IsSameDay(dateOne: Date, dateTwo: Date): boolean {\r\n        return (dateOne && dateTwo &&\r\n            dateOne.getDate() === dateTwo.getDate()\r\n            && dateOne.getMonth() === dateTwo.getMonth()\r\n            && dateOne.getFullYear() === dateTwo.getFullYear());\r\n    }\r\n\r\n    public static IsInBetween(date: Date, startDate: Date, endDate: Date, withTime: boolean = true): boolean {\r\n        if (startDate && endDate) {\r\n            if (withTime) {\r\n                return (date > startDate && date < endDate);\r\n            } else {\r\n                const dateWithoutTime: number = new Date(date).setHours(0, 0, 0, 0),\r\n                    dateFromWithoutTime: number = new Date(startDate).setHours(0, 0, 0, 0),\r\n                    dateToWithoutTime: number = new Date(endDate).setHours(0, 0, 0, 0);\r\n                return dateWithoutTime >= dateFromWithoutTime && dateWithoutTime <= dateToWithoutTime;\r\n            }\r\n        }\r\n    }\r\n\r\n    public static IsMonday(date: Date): boolean {\r\n        return date.getDay() === 1;\r\n    }\r\n\r\n    public static IsSunday(date: Date): boolean {\r\n        return date.getDay() === 0;\r\n    }\r\n\r\n    public static IsToday(date: Date): boolean {\r\n        const today: Date = new Date();\r\n        return DateUtils.IsSameDay(today, date);\r\n    }\r\n\r\n    // Returns date format like it would when using a pipe in the templete, ie: \"1 okt. 2020\"\r\n    public static ParseDateInShortDateFormat(date: Date, locale: string): string {\r\n        this.datePipe = new DatePipe(locale);\r\n        const parsedDate: string = this.datePipe.transform(date);\r\n        return parsedDate;\r\n    }\r\n\r\n    // Transforms a string that is formatted like \"'17-08-2014'<=?<='17-08-2021'\" into \"'17-08-2014' Untill '17-08-2021'\"\r\n    public static getFormattedDateRangeString(dateRangeString: string, separator: string = \" - \"): string {\r\n        let newString: string = dateRangeString;\r\n        newString = newString.replace(\"<=?<=\", ` ${separator} `);\r\n        newString = newString.replace(/'/g, \"\");\r\n\r\n        return newString;\r\n    }\r\n\r\n    public static SetDateOrDateRangeObjectHoursZero(date: Date | DateRange): void {\r\n        if (date instanceof DateRange) {\r\n            if (date.startDate) {\r\n                date.startDate.setHours(0, 0, 0);\r\n            }\r\n            if (date.endDate) {\r\n                date.endDate.setHours(0, 0, 0);\r\n            }\r\n        } else if (!!date && (date instanceof Date)) {\r\n            date.setHours(0, 0, 0, 0);\r\n        }\r\n    }\r\n\r\n    private static _DateToTimeStringWithDateFormat(value: Date, dateFormat: string = \"d-m-y\"): string {\r\n        if (!value) {\r\n            return \"\";\r\n        }\r\n\r\n        const hours: string = value.getHours() < 10 ? \"0\" + value.getHours() : \"\" + value.getHours();\r\n        const minutes: string = value.getMinutes() < 10 ? \"0\" + value.getMinutes() : \"\" + value.getMinutes();\r\n        return this.ParseDate(value, dateFormat) + \" \" + [hours, minutes].join(\":\");\r\n    }\r\n}\r\n"]}

package/esm2015/lib/utils/enum-utils.js

@@ -0,0 +1,128 @@
+import { CoDomainValue } from "@colijnit/mainapi/build/model/co-domain-value.bo";
+import { NumberUtils } from "./number-utils";
+import { StringUtils } from "./string-utils";
+// @dynamic
+export class EnumUtils {
+    // Returns a new array with all string values (not keys) of given string enum class.
+    static StringEnumToArray(clazz) {
+        const asArray = [];
+        const keys = Object.keys(clazz);
+        for (let i = 0, len = keys.length; i < len; i++) {
+            asArray.push(clazz[keys[i]]);
+        }
+        return asArray;
+    }
+    /**
+     * Returns a single string representation of given string enum class
+     * @param clazz
+     * @returns {string} eg "input-lov-slideout, financial-customer-group-select" for a given clazz of InputLovSlideoutComponentSelectors
+     */
+    static StringEnumToSingleString(clazz) {
+        return StringEnumToSingleString(clazz);
+    }
+    // Get the number values from an enum
+    static GetNumberEnumValues(numberEnumClass) {
+        return this.GetObjValues(numberEnumClass).filter(value => NumberUtils.IsNumber(value));
+    }
+    // Get the the property object value names in string format from the enum
+    static GetStringEnumValues(stringEnumClass) {
+        return this.GetObjValues(stringEnumClass).filter(value => StringUtils.IsString(value));
+    }
+    static GetObjValues(numberEnumClass) {
+        return Object.keys(numberEnumClass).map(key => numberEnumClass[key]);
+    }
+    /**
+     * Returns the enum in object format to make handling easier
+     * Works for Enums with the following format:
+     * foo: 1
+     * bar: 2
+     * etc...
+     * @param enumClass
+     * @returns {Object}
+     */
+    static createObjectFromEnum(enumClass) {
+        // const objectifiedEnum: { refNumber: number; name: string }[] = [];
+        const objectifiedEnum = [];
+        for (const enumItem in enumClass) {
+            if (typeof enumClass[enumItem] === "number") {
+                objectifiedEnum.push({ key: enumClass[enumItem], value: enumItem });
+            }
+        }
+        return objectifiedEnum;
+    }
+    static getStringEnumKeysArray(enumType) {
+        const members = Object.keys(enumType);
+        if (!EnumUtils.isNumeral(enumType)) {
+            return members;
+        }
+        const keys = [];
+        members.forEach((x) => {
+            const parsedValue = parseInt(x, 10);
+            if (Number.isNaN(parsedValue)) {
+                keys.push(x);
+            }
+        });
+        return keys;
+    }
+    static buildPromiseDomainValueListFromEnumClass(enumClass, dictionary, keysAsDescription = false) {
+        return new Promise((resolve, reject) => {
+            try {
+                resolve(EnumUtils.buildDomainValueListFromEnumClass(enumClass, dictionary, keysAsDescription));
+            }
+            catch (e) {
+                reject();
+            }
+        });
+    }
+    static buildDomainValueListFromEnumClass(enumClass, dictionary, keysAsDescription = false) {
+        const collection = [];
+        if (keysAsDescription) {
+            const enumKeys = EnumUtils.getStringEnumKeysArray(enumClass);
+            enumKeys.forEach((key, index) => {
+                const domainObjectForLov = new CoDomainValue();
+                domainObjectForLov.code = enumClass[key];
+                domainObjectForLov.description = dictionary.get(key);
+                domainObjectForLov.sequence = index;
+                collection.push(domainObjectForLov);
+            });
+        }
+        else {
+            EnumUtils.StringEnumToArray(enumClass).forEach((strEnumVal, index) => {
+                const domainObjectForLov = new CoDomainValue();
+                domainObjectForLov.code = strEnumVal;
+                domainObjectForLov.description = dictionary.get(strEnumVal);
+                domainObjectForLov.sequence = index;
+                collection.push(domainObjectForLov);
+            });
+        }
+        return collection;
+    }
+    static getKeyByValue(enumType, enumValue) {
+        return Object.keys(enumType)[Object.values(enumType).indexOf(enumValue)];
+    }
+    static isNumeral(enumType) {
+        const members = Object.keys(enumType);
+        if (!members.some((x) => true)) {
+            throw new TypeError("Invalid enumeration type.");
+        }
+        let parsedCount = 0;
+        members.forEach((x) => {
+            const parsedValue = parseInt(x, 10);
+            if (!Number.isNaN(parsedValue)) {
+                parsedCount++;
+            }
+        });
+        return parsedCount === members.length / 2;
+    }
+}
+// Outside the class because it's used to generate component selectors, and aot can't call statics.
+export function StringEnumToSingleString(clazz) {
+    let str = "";
+    const keys = Object.keys(clazz);
+    for (let i = 0, len = keys.length; i < len; i++) {
+        str += clazz[keys[i]] + ", ";
+    }
+    str = StringUtils.RemoveLastChars(str, 2);
+    return str;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"enum-utils.js","sourceRoot":"","sources":["../../../../../projects/sharedcomponents/src/lib/utils/enum-utils.ts"],"names":[],"mappings":"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","sourcesContent":["// Static utility function holder related to enums.\r\nimport {KeyValuePair} from \"../interface/key-value-pair\";\r\nimport {CoDomainValue} from \"@colijnit/mainapi/build/model/co-domain-value.bo\";\r\nimport {NumberUtils} from \"./number-utils\";\r\nimport {StringUtils} from \"./string-utils\";\r\nimport {DictionaryService} from \"../service/dictionary.service\";\r\n// @dynamic\r\nexport class EnumUtils {\r\n    // Returns a new array with all string values (not keys) of given string enum class.\r\n    public static StringEnumToArray(clazz: any): string[] {\r\n        const asArray: any[] = [];\r\n\r\n        const keys: string[] = Object.keys(clazz);\r\n        for (let i: number = 0, len: number = keys.length; i < len; i++) {\r\n            asArray.push(clazz[keys[i]]);\r\n        }\r\n\r\n        return asArray;\r\n    }\r\n\r\n    /**\r\n     * Returns a single string representation of given string enum class\r\n     * @param clazz\r\n     * @returns {string} eg \"input-lov-slideout, financial-customer-group-select\" for a given clazz of InputLovSlideoutComponentSelectors\r\n     */\r\n    public static StringEnumToSingleString(clazz: any): string {\r\n        return StringEnumToSingleString(clazz);\r\n    }\r\n\r\n    // Get the number values from an enum\r\n    public static GetNumberEnumValues(numberEnumClass: any): any[] {\r\n        return this.GetObjValues(numberEnumClass).filter(value => NumberUtils.IsNumber(value));\r\n    }\r\n\r\n    // Get the the property object value names in string format from the enum\r\n    public static GetStringEnumValues(stringEnumClass: any): any[] {\r\n        return this.GetObjValues(stringEnumClass).filter(value => StringUtils.IsString(value));\r\n    }\r\n\r\n    public static GetObjValues(numberEnumClass: any): (number | string)[] {\r\n        return Object.keys(numberEnumClass).map(key => numberEnumClass[key]);\r\n    }\r\n\r\n    /**\r\n     * Returns the enum in object format to make handling easier\r\n     * Works for Enums with the following format:\r\n     * foo: 1\r\n     * bar: 2\r\n     * etc...\r\n     * @param enumClass\r\n     * @returns {Object}\r\n     */\r\n    public static createObjectFromEnum(enumClass: any): KeyValuePair[] {\r\n       // const objectifiedEnum: { refNumber: number; name: string }[] = [];\r\n        const objectifiedEnum: KeyValuePair[] = [];\r\n\r\n        for (const enumItem in enumClass) {\r\n            if (typeof enumClass[enumItem] === \"number\") {\r\n                objectifiedEnum.push({key: <number>enumClass[enumItem], value: enumItem});\r\n            }\r\n        }\r\n\r\n        return objectifiedEnum;\r\n    }\r\n\r\n    public static getStringEnumKeysArray(enumType: object): string[] {\r\n        const members = Object.keys(enumType);\r\n        if (!EnumUtils.isNumeral(enumType)) {\r\n            return members;\r\n        }\r\n\r\n        const keys: string[] = [];\r\n        members.forEach((x) => {\r\n            const parsedValue = parseInt(x, 10);\r\n            if (Number.isNaN(parsedValue)) {\r\n                keys.push(x);\r\n            }\r\n        });\r\n        return keys;\r\n    }\r\n\r\n    public static  buildPromiseDomainValueListFromEnumClass(enumClass: any, dictionary: DictionaryService, keysAsDescription: boolean = false): Promise<CoDomainValue[]> {\r\n        return new Promise((resolve, reject) => {\r\n            try {\r\n                resolve(EnumUtils.buildDomainValueListFromEnumClass(enumClass, dictionary, keysAsDescription));\r\n            } catch (e) {\r\n                reject();\r\n            }\r\n        });\r\n    }\r\n\r\n    public static buildDomainValueListFromEnumClass(enumClass: any, dictionary: DictionaryService, keysAsDescription: boolean = false): CoDomainValue[] {\r\n        const collection: CoDomainValue[] = [];\r\n\r\n        if (keysAsDescription) {\r\n            const enumKeys: string[] = EnumUtils.getStringEnumKeysArray(enumClass);\r\n            enumKeys.forEach((key: string, index: number) => {\r\n                const domainObjectForLov: CoDomainValue = new CoDomainValue();\r\n                domainObjectForLov.code = enumClass[key];\r\n                domainObjectForLov.description = dictionary.get(key);\r\n                domainObjectForLov.sequence = index;\r\n                collection.push(domainObjectForLov);\r\n            });\r\n        } else {\r\n            EnumUtils.StringEnumToArray(enumClass).forEach((strEnumVal: string, index: number) => {\r\n                const domainObjectForLov: CoDomainValue = new CoDomainValue();\r\n                domainObjectForLov.code = strEnumVal;\r\n                domainObjectForLov.description = dictionary.get(strEnumVal);\r\n                domainObjectForLov.sequence = index;\r\n                collection.push(domainObjectForLov);\r\n            });\r\n        }\r\n\r\n        return collection;\r\n    }\r\n\r\n    public static getKeyByValue(enumType: object, enumValue: string): string {\r\n        return Object.keys(enumType)[Object.values(enumType).indexOf(enumValue)];\r\n    }\r\n\r\n    private static isNumeral(enumType: object): boolean {\r\n        const members = Object.keys(enumType);\r\n        if (!members.some((x) => true)) {\r\n            throw new TypeError(\"Invalid enumeration type.\");\r\n        }\r\n        let parsedCount = 0;\r\n        members.forEach((x) => {\r\n            const parsedValue = parseInt(x, 10);\r\n            if (!Number.isNaN(parsedValue)) {\r\n                parsedCount++;\r\n            }\r\n        });\r\n        return parsedCount === members.length / 2;\r\n    }\r\n\r\n}\r\n\r\n// Outside the class because it's used to generate component selectors, and aot can't call statics.\r\nexport function StringEnumToSingleString(clazz: any): string {\r\n    let str: string = \"\";\r\n\r\n    const keys: string[] = Object.keys(clazz);\r\n    for (let i: number = 0, len: number = keys.length; i < len; i++) {\r\n        str += clazz[keys[i]] + \", \";\r\n    }\r\n\r\n    str = StringUtils.RemoveLastChars(str, 2);\r\n    return str;\r\n}\r\n"]}

package/esm2015/lib/utils/function/not-nill.function.js

@@ -0,0 +1,5 @@
+// @returns true iff given value does not equals null and does not equal undefined
+export function notNill(value) {
+    return value !== null && value !== undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90LW5pbGwuZnVuY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zaGFyZWRjb21wb25lbnRzL3NyYy9saWIvdXRpbHMvZnVuY3Rpb24vbm90LW5pbGwuZnVuY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsa0ZBQWtGO0FBQ2xGLE1BQU0sVUFBVSxPQUFPLENBQUMsS0FBVTtJQUM5QixPQUFPLEtBQUssS0FBSyxJQUFJLElBQUksS0FBSyxLQUFLLFNBQVMsQ0FBQztBQUNqRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHJldHVybnMgdHJ1ZSBpZmYgZ2l2ZW4gdmFsdWUgZG9lcyBub3QgZXF1YWxzIG51bGwgYW5kIGRvZXMgbm90IGVxdWFsIHVuZGVmaW5lZFxyXG5leHBvcnQgZnVuY3Rpb24gbm90TmlsbCh2YWx1ZTogYW55KTogYm9vbGVhbiB7XHJcbiAgICByZXR1cm4gdmFsdWUgIT09IG51bGwgJiYgdmFsdWUgIT09IHVuZGVmaW5lZDtcclxufVxyXG4iXX0=

package/esm2015/lib/utils/is-nill.function.js

@@ -0,0 +1,5 @@
+// @returns true iff given value equals null or equals undefined
+export function isNill(value) {
+    return value === null || value === undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtbmlsbC5mdW5jdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NoYXJlZGNvbXBvbmVudHMvc3JjL2xpYi91dGlscy9pcy1uaWxsLmZ1bmN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGdFQUFnRTtBQUNoRSxNQUFNLFVBQVUsTUFBTSxDQUFDLEtBQVU7SUFDN0IsT0FBTyxLQUFLLEtBQUssSUFBSSxJQUFJLEtBQUssS0FBSyxTQUFTLENBQUM7QUFDakQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEByZXR1cm5zIHRydWUgaWZmIGdpdmVuIHZhbHVlIGVxdWFscyBudWxsIG9yIGVxdWFscyB1bmRlZmluZWRcclxuZXhwb3J0IGZ1bmN0aW9uIGlzTmlsbCh2YWx1ZTogYW55KTogYm9vbGVhbiB7XHJcbiAgICByZXR1cm4gdmFsdWUgPT09IG51bGwgfHwgdmFsdWUgPT09IHVuZGVmaW5lZDtcclxufSJdfQ==

package/esm2015/lib/utils/map-utils.js

@@ -0,0 +1,41 @@
+// Static utility functions holder related to Maps.
+export class MapUtils {
+    /**
+     * Returns the first key from given map, for which the value filter holds true. Basically a reverse Map.get(key) function.
+     * @param map
+     * @param valueFilter For the first value that returns true for this filter functions, its key will be returned.
+     */
+    static FindKeyByValue(map, valueFilter) {
+        if (!map || !valueFilter) {
+            return undefined;
+        }
+        let foundKey = undefined;
+        let keyWasFound = false;
+        map.forEach((value, key) => {
+            if (!keyWasFound && valueFilter.call(this, value)) {
+                foundKey = key;
+                keyWasFound = true;
+            }
+        });
+        return foundKey;
+    }
+    /**
+     * Inserts given arrayEntry into given map, under given mapKey. What's special here, is that a NEW map entry is created with an array
+     * containing the single [arrayEntry] item, if no entry yet existed.
+     * @param map
+     * @param mapKey
+     * @param arrayEntry
+     */
+    static InsertArrayItemIntoMap(map, mapKey, arrayEntry) {
+        if (!map) {
+            return;
+        }
+        if (!map.has(mapKey)) {
+            map.set(mapKey, [arrayEntry]);
+        }
+        else {
+            map.get(mapKey).push(arrayEntry);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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