nmce-func 0.0.4 → 0.0.8

package/esm2020/_func/dateFunc.mjs

@@ -0,0 +1,316 @@
+import moment from 'moment';
+export class DateFunc {
+    /**
+     * Transform UTC DateTime to local date without H, M and S. For example, the month day of 2018-01-23T22:00:00Z is 24 in Australia.
+     * @param dtUtc
+     * @param offsetMinutes if not defined, it will be new Date().getTimezoneOffset(). //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset
+     */
+    static dateTimeUtcToLocalDateNumber(dtUtc) {
+        if (!dtUtc) {
+            return 0; //0 is better for calculation by the clients.
+        }
+        const localDt = DateFunc.dateTimeUtcToLocalDateTime(dtUtc);
+        const localDNum = localDt.setHours(0, 0, 0, 0);
+        return localDNum;
+    }
+    /**
+     * Date only. However, the date may still be in UTC.
+     * @param dtUtc
+     */
+    static dateTimeUtcToLocalDate(dtUtc) {
+        const localDt = DateFunc.dateTimeUtcToLocalDateTime(dtUtc);
+        const localD = localDt.setHours(0, 0, 0, 0);
+        return new Date(localD);
+    }
+    static localISODateString(dtUtc) {
+        const dt = moment(dtUtc).local();
+        return dt.format('YYYY-MM-DD');
+    }
+    /**
+     * locate date ONLY (no time) to UTC date.
+     * @param dt if dt contain time info, it will become dt.setHours(0, 0, 0, 0)
+     */
+    static localDateToUtc(d) {
+        const dt = moment(d).toDate();
+        const n = dt.setHours(0, 0, 0, 0);
+        const offset = dt.getTimezoneOffset() * 60000;
+        return new Date(n + offset);
+    }
+    static getTimezoneOffset() {
+        const dt = this.today;
+        return dt.getTimezoneOffset();
+    }
+    /**
+     * Transform UTC DateTime to local dateTime.
+     * @param dtUtc
+     * @param offsetMinutes if not defined, it will be new Date().getTimezoneOffset(). //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset
+     */
+    static dateTimeUtcToLocalDateTime(dtUtc) {
+        const stillUtc = moment.utc(dtUtc).toDate();
+        return moment(stillUtc).local().toDate();
+    }
+    static dateTimeUtcToLocaMoment(dtUtc) {
+        const stillUtc = moment.utc(dtUtc);
+        return stillUtc.local();
+    }
+    static getEndOfWeek(dt) {
+        return moment(dt).endOf('isoWeek').toDate();
+    }
+    static getStartOfWeek(dt) {
+        return moment(dt).startOf('isoWeek').toDate();
+    }
+    static getEndOfMonth(dt) {
+        //  return new Date(dt.getFullYear(), dt.getMonth() + 1, 0, 23, 59, 59, 999);
+        return moment(dt).endOf('month').toDate();
+    }
+    static getStartOfMonth(dt) {
+        return moment(dt).startOf('month').toDate();
+    }
+    static getDaysBetweenDates(dt1, dt2) {
+        return this.getDaysBetween(dt1, dt2);
+    }
+    static getEndOfDate(dt) {
+        return dt ? new Date(dt.setHours(23, 59, 59, 999)) :
+            new Date(this.now.setHours(23, 59, 59, 999));
+    }
+    static getStartOfDate(dt) {
+        return moment(dt).startOf('day').toDate();
+    }
+    static getEndOfToday() {
+        //	return new Date((new Date(Date.now())).setHours(23, 59, 59, 999));
+        return moment(Date.now()).endOf('day').toDate();
+    }
+    static getStartOfToday() {
+        //	return new Date((new Date(Date.now())).setHours(0, 0, 0, 0));
+        return moment(Date.now()).startOf('day').toDate();
+    }
+    //inspired https://stackoverflow.com/questions/563406/add-days-to-javascript-date
+    static addDays(dt, days = 0) {
+        const dat = moment(dt);
+        dat.add(days, 'days');
+        return dat.toDate();
+    }
+    static subtractDays(dt, days = 0) {
+        const dat = moment(dt);
+        dat.subtract(days, 'days');
+        return dat.toDate();
+    }
+    /**
+     * Start of today
+     */
+    static get today() {
+        return this.getStartOfToday();
+    }
+    static get now() {
+        return new Date(Date.now());
+    }
+    static getNext5MinuteMark() {
+        const m = moment().set('second', 0).set('millisecond', 0);
+        const minute = m.minute();
+        const mod = minute % 5;
+        if (mod) {
+            const delta = 5 - mod;
+            return m.add(delta, 'm').toDate();
+        }
+        return m.toDate();
+    }
+    static getYMD(d) {
+        return moment(d).format('YYYYMMDD');
+    }
+    static getDMYWithSlash(d) {
+        return moment(d).format('DD/MM/YYYY');
+    }
+    static getDMYHmWithSlash(d) {
+        return moment(d).format('DD/MM/YYYY HH:mm');
+    }
+    static getMcpTime(dt) {
+        return moment(dt).format('HH:mm:ss.SSSZ');
+    }
+    /**
+     * In 24 hour format
+     * @param dtUtc
+     */
+    static getLocalDMYHmWithSlash(dtUtc) {
+        const d = DateFunc.dateTimeUtcToLocalDateTime(dtUtc);
+        return moment(d).format('DD/MM/YYYY HH:mm');
+    }
+    /**
+     * Offset minutes comparing with today
+     */
+    static getOffsetMinutes(dtUtc) {
+        const dm1 = moment(dtUtc);
+        const dm2 = moment(new Date().setHours(0, 0, 0, 0));
+        return dm1.diff(dm2, 'minutes');
+    }
+    static getDaysBetween(d1, d2) {
+        const dm1 = moment(d1);
+        const dm2 = moment(d2);
+        return dm2.diff(dm1, 'days');
+    }
+    /**
+     * Get hour of the date. If Date is not defined, the hour will be current hour.
+     * @param dtUtc
+     */
+    static getHour(dtUtc) {
+        const m = moment(dtUtc);
+        return m.hours();
+    }
+    static getMinute(dtUtc) {
+        const m = moment(dtUtc);
+        return m.minutes();
+    }
+    static composeDateTime(dt, h = 0, minute = 0) {
+        const mt = moment(dt);
+        return new Date(mt.toDate().setHours(h, minute, 0, 0));
+    }
+    static olderThan24Hours(d) {
+        const m = moment(d);
+        return moment().diff(m, 'hours') >= 24;
+    }
+    static olderThan24HoursUtc(dtUtc) {
+        return DateFunc.getHourAgeUtc(dtUtc) >= 24;
+    }
+    static olderThanHours(d, hours) {
+        const m = moment(d);
+        return moment().diff(m, 'hours') >= hours;
+    }
+    static olderThanHoursUtc(dtUtc, hours) {
+        return DateFunc.getHourAgeUtc(dtUtc) >= hours;
+    }
+    static olderThanMinutes(d, minutes) {
+        const m = moment(d);
+        return moment().diff(m, 'minutes') >= minutes;
+    }
+    /**
+     * It could be 11PM yesterday, and 1 AM today. Actually based on local today.
+     */
+    static olderThan1Day(dtUtc) {
+        return DateFunc.getDayAgeUtc(dtUtc) > 0;
+    }
+    static getHourAge(d) {
+        const m = moment(d);
+        return moment().diff(m, 'hours');
+    }
+    static getHourAgeUtc(dtUtc) {
+        const m = moment.utc(dtUtc);
+        return moment.utc().diff(m, 'hours');
+    }
+    /**
+     * Compare utc date with utc now.
+     * @param dtUtc
+     */
+    static getDayAgeUtc(dtUtc) {
+        const m = moment.utc(dtUtc);
+        return moment.utc().diff(m, 'days');
+    }
+    /**
+     * How many years from now.
+     * @param d
+     * @returns
+     */
+    static getAge(d) {
+        const m = moment(d);
+        return moment().diff(m, 'years');
+    }
+    /**
+     * Year of date.
+     * @param d
+     * @returns
+     */
+    static getYear(d) {
+        const m = moment(d);
+        return m.year();
+    }
+    static getUtcNow() {
+        return moment.utc().toDate();
+    }
+    static addMinutes(d, m) {
+        return moment(d).add(m, 'm').toDate();
+    }
+    static addMonth(d, m) {
+        return moment(d).add(m, 'M').toDate();
+    }
+    static getDuration(d1, d2) {
+        const md1 = moment(d1);
+        const md2 = moment(d2);
+        return moment.duration(md2.diff(md1));
+    }
+    /**
+     * Convert minutes from midnight to HH:mm text
+     * @param mins
+     */
+    static getHMFromMins(mins) {
+        // do not include the first validation check if you want, for example,
+        // getTimeFromMins(1530) to equal getTimeFromMins(90) (i.e. mins rollover)
+        if (mins >= 24 * 60 || mins < 0) {
+            throw new RangeError('Valid input should be greater than or equal to 0 and less than 1440.');
+        }
+        const h = mins / 60 | 0, m = mins % 60 | 0;
+        return moment.utc().hours(h).minutes(m).format('HH:mm');
+    }
+    static getMinutesSinceMidnight(d) {
+        const m = moment(d);
+        const midnight = moment(d).startOf('day'); //Mutates the original moment by setting it to the start of a unit of time. So I have better not to use m which wil be changed by calling this function
+        return m.diff(midnight, 'minutes');
+    }
+    static getMinutesBetween(start, end) {
+        const m = moment(start);
+        const m2 = moment(end);
+        return m2.diff(m, 'minutes');
+    }
+    /**
+     * Parse json string with date serialized into string, and get proper date object back
+     * @param s
+     */
+    static dateSafeJsonParse(s) {
+        return JSON.parse(s, this.dateReviver);
+    }
+    static dateReviver(key, value) {
+        if (DateFunc.isSerializedDate(value)) {
+            return (new Date(value));
+        }
+        // If it's not a date-string, we want to return the value as-is. If we fail to return
+        // a value, it will be omitted from the resultant data structure.
+        return (value);
+    }
+    // I determine if the given value is a string that matches the serialized-date pattern.
+    static isSerializedDate(value) {
+        // Dates are serialized in TZ format, example: '1981-12-20T04:00:14.000Z'.
+        const datePattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+        return (DateFunc.isString(value) && datePattern.test(value));
+    }
+    // I determine if the given value is a String.
+    static isString(value) {
+        return ({}.toString.call(value) === '[object String]');
+    }
+    static dateSafeParse(s) {
+        const m = moment(s);
+        return m.toDate();
+    }
+    static composeDateWithMinutes(d, minute) {
+        const m = moment(d);
+        const midnight = moment(d).startOf('day'); // Mutates the original moment by setting it to the start of a unit of time. So I have better not to use m which wil be changed by calling this function
+        midnight.add(minute, 'minutes');
+        return midnight.toDate();
+    }
+    /**
+     * Safe compare since date data may be considered as string rather than date.
+     * @param d1
+     * @param d2
+     */
+    static compare(d1, d2) {
+        if (!d1 && !d2) {
+            return 0;
+        }
+        if (!d1) {
+            return -NaN;
+        }
+        if (!d2) {
+            return NaN;
+        }
+        const dd1 = (new Date(d1)).valueOf();
+        const dd2 = (new Date(d2)).valueOf();
+        return dd1 - dd2;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dateFunc.js","sourceRoot":"","sources":["../../../../projects/nmce-func/src/_func/dateFunc.ts"],"names":[],"mappings":"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","sourcesContent":["import moment from 'moment';\r\n\r\nexport class DateFunc {\r\n\r\n\t/**\r\n\t * Transform UTC DateTime to local date without H, M and S. For example, the month day of 2018-01-23T22:00:00Z is 24 in Australia.\r\n\t * @param dtUtc\r\n\t * @param offsetMinutes if not defined, it will be new Date().getTimezoneOffset(). //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset\r\n\t */\r\n\tstatic dateTimeUtcToLocalDateNumber(dtUtc: Date | null | undefined): number {\r\n\t\tif (!dtUtc) {\r\n\t\t\treturn 0; //0 is better for calculation by the clients.\r\n\t\t}\r\n\r\n\t\tconst localDt = DateFunc.dateTimeUtcToLocalDateTime(dtUtc);\r\n\t\tconst localDNum = localDt.setHours(0, 0, 0, 0);\r\n\r\n\t\treturn localDNum;\r\n\t}\r\n\r\n\t/**\r\n\t * Date only. However, the date may still be in UTC.\r\n\t * @param dtUtc\r\n\t */\r\n\tstatic dateTimeUtcToLocalDate(dtUtc: Date | null | undefined): Date {\r\n\t\tconst localDt = DateFunc.dateTimeUtcToLocalDateTime(dtUtc);\r\n\t\tconst localD = localDt.setHours(0, 0, 0, 0);\r\n\t\treturn new Date(localD);\r\n\t}\r\n\r\n\tstatic localISODateString(dtUtc: Date | null | undefined): string {\r\n\t\tconst dt = moment(dtUtc).local();\r\n\t\treturn dt.format('YYYY-MM-DD');\r\n\t}\r\n\r\n\t/**\r\n\t * locate date ONLY (no time) to UTC date.\r\n\t * @param dt if dt contain time info, it will become dt.setHours(0, 0, 0, 0)\r\n\t */\r\n\tstatic localDateToUtc(d: Date | number | null | undefined | string): Date {\r\n\t\tconst dt = moment(d).toDate();\r\n\t\tconst n = dt.setHours(0, 0, 0, 0);\r\n\t\tconst offset = dt.getTimezoneOffset() * 60000;\r\n\t\treturn new Date(n + offset);\r\n\t}\r\n\r\n\tstatic getTimezoneOffset(): number {\r\n\t\tconst dt = this.today;\r\n\t\treturn dt.getTimezoneOffset();\r\n\t}\r\n\r\n\t/**\r\n\t * Transform UTC DateTime to local dateTime.\r\n\t * @param dtUtc\r\n\t * @param offsetMinutes if not defined, it will be new Date().getTimezoneOffset(). //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset\r\n\t */\r\n\tstatic dateTimeUtcToLocalDateTime(dtUtc: Date | null | undefined): Date {\r\n\t\tconst stillUtc = moment.utc(dtUtc).toDate();\r\n\t\treturn moment(stillUtc).local().toDate();\r\n\t}\r\n\r\n\tstatic dateTimeUtcToLocaMoment(dtUtc: Date | null | undefined): moment.Moment {\r\n\t\tconst stillUtc = moment.utc(dtUtc);\r\n\t\treturn stillUtc.local();\r\n\t}\r\n\r\n\tstatic getEndOfWeek(dt: Date | null | undefined | number) {\r\n\t\treturn moment(dt).endOf('isoWeek').toDate();\r\n\t}\r\n\r\n\tstatic getStartOfWeek(dt: Date | null | undefined | number) {\r\n\t\treturn moment(dt).startOf('isoWeek').toDate();\r\n\t}\r\n\r\n\tstatic getEndOfMonth(dt: Date | null | undefined | number) {\r\n\t\t//  return new Date(dt.getFullYear(), dt.getMonth() + 1, 0, 23, 59, 59, 999);\r\n\t\treturn moment(dt).endOf('month').toDate();\r\n\t}\r\n\r\n\tstatic getStartOfMonth(dt: Date | null | undefined | number) {\r\n\t\treturn moment(dt).startOf('month').toDate();\r\n\t}\r\n\r\n\tstatic getDaysBetweenDates(dt1: Date | null | undefined, dt2: Date | null | undefined) {\r\n\t\treturn this.getDaysBetween(dt1, dt2);\r\n\t}\r\n\r\n\tstatic getEndOfDate(dt: Date | null | undefined): Date {\r\n\t\treturn dt ? new Date(dt.setHours(23, 59, 59, 999)) :\r\n\t\t\tnew Date(this.now.setHours(23, 59, 59, 999));\r\n\t}\r\n\r\n\tstatic getStartOfDate(dt: Date | null | undefined): Date {\r\n\t\treturn moment(dt).startOf('day').toDate();\r\n\t}\r\n\r\n\tstatic getEndOfToday(): Date {\r\n\t\t//\treturn new Date((new Date(Date.now())).setHours(23, 59, 59, 999));\r\n\t\treturn moment(Date.now()).endOf('day').toDate();\r\n\r\n\t}\r\n\r\n\tstatic getStartOfToday(): Date {\r\n\t\t//\treturn new Date((new Date(Date.now())).setHours(0, 0, 0, 0));\r\n\t\treturn moment(Date.now()).startOf('day').toDate();\r\n\t}\r\n\r\n\t//inspired https://stackoverflow.com/questions/563406/add-days-to-javascript-date\r\n\tstatic addDays(dt: Date | null | undefined, days: number = 0) {\r\n\t\tconst dat = moment(dt);\r\n\t\tdat.add(days, 'days');\r\n\t\treturn dat.toDate();\r\n\t}\r\n\r\n\tstatic subtractDays(dt: Date | null | undefined, days: number = 0) {\r\n\t\tconst dat = moment(dt);\r\n\t\tdat.subtract(days, 'days');\r\n\t\treturn dat.toDate();\r\n\t}\r\n\r\n\t/**\r\n\t * Start of today\r\n\t */\r\n\tstatic get today(): Date {\r\n\t\treturn this.getStartOfToday();\r\n\t}\r\n\r\n\tstatic get now(): Date {\r\n\t\treturn new Date(Date.now());\r\n\t}\r\n\r\n\tstatic getNext5MinuteMark(): Date {\r\n\t\tconst m = moment().set('second', 0).set('millisecond', 0);\r\n\t\tconst minute = m.minute();\r\n\t\tconst mod = minute % 5;\r\n\t\tif (mod) {\r\n\t\t\tconst delta = 5 - mod;\r\n\t\t\treturn m.add(delta, 'm').toDate();\r\n\t\t}\r\n\r\n\t\treturn m.toDate();\r\n\t}\r\n\r\n\tstatic getYMD(d: Date) {\r\n\t\treturn moment(d).format('YYYYMMDD');\r\n\t}\r\n\r\n\tstatic getDMYWithSlash(d: Date) {\r\n\t\treturn moment(d).format('DD/MM/YYYY');\r\n\t}\r\n\r\n\tstatic getDMYHmWithSlash(d: Date) {\r\n\t\treturn moment(d).format('DD/MM/YYYY HH:mm');\r\n\t}\r\n\r\n\tstatic getMcpTime(dt: Date | null | undefined) {\r\n\t\treturn moment(dt).format('HH:mm:ss.SSSZ');\r\n\t}\r\n\r\n\t/**\r\n\t * In 24 hour format\r\n\t * @param dtUtc\r\n\t */\r\n\tstatic getLocalDMYHmWithSlash(dtUtc: Date | null | undefined) {\r\n\t\tconst d = DateFunc.dateTimeUtcToLocalDateTime(dtUtc);\r\n\t\treturn moment(d).format('DD/MM/YYYY HH:mm');\r\n\t}\r\n\r\n\t/**\r\n\t * Offset minutes comparing with today\r\n\t */\r\n\tstatic getOffsetMinutes(dtUtc: Date | null | undefined | number): number {\r\n\t\tconst dm1 = moment(dtUtc);\r\n\t\tconst dm2 = moment(new Date().setHours(0, 0, 0, 0));\r\n\t\treturn dm1.diff(dm2, 'minutes');\r\n\t}\r\n\r\n\tstatic getDaysBetween(d1?: Date | number | null | undefined, d2?: Date | number | null | undefined): number {\r\n\t\tconst dm1 = moment(d1);\r\n\t\tconst dm2 = moment(d2);\r\n\t\treturn dm2.diff(dm1, 'days');\r\n\t}\r\n\r\n\t/**\r\n\t * Get hour of the date. If Date is not defined, the hour will be current hour.\r\n\t * @param dtUtc\r\n\t */\r\n\tstatic getHour(dtUtc: Date | null | undefined | number): number {\r\n\t\tconst m = moment(dtUtc);\r\n\t\treturn m.hours();\r\n\t}\r\n\r\n\tstatic getMinute(dtUtc: Date | null | undefined | number): number {\r\n\t\tconst m = moment(dtUtc);\r\n\t\treturn m.minutes();\r\n\t}\r\n\r\n\tstatic composeDateTime(dt: Date | null | undefined, h: number = 0, minute: number = 0): Date {\r\n\t\tconst mt = moment(dt);\r\n\t\treturn new Date(mt.toDate().setHours(h, minute, 0, 0));\r\n\t}\r\n\r\n\tstatic olderThan24Hours(d: Date | null | undefined): boolean {\r\n\t\tconst m = moment(d);\r\n\t\treturn moment().diff(m, 'hours') >= 24;\r\n\t}\r\n\r\n\tstatic olderThan24HoursUtc(dtUtc: Date | null | undefined): boolean {\r\n\t\treturn DateFunc.getHourAgeUtc(dtUtc) >= 24;\r\n\t}\r\n\r\n\tstatic olderThanHours(d: Date, hours: number) {\r\n\t\tconst m = moment(d);\r\n\t\treturn moment().diff(m, 'hours') >= hours;\r\n\t}\r\n\r\n\tstatic olderThanHoursUtc(dtUtc: Date | null | undefined, hours: number): boolean {\r\n\t\treturn DateFunc.getHourAgeUtc(dtUtc) >= hours;\r\n\t}\r\n\r\n\tstatic olderThanMinutes(d: Date, minutes: number) {\r\n\t\tconst m = moment(d);\r\n\t\treturn moment().diff(m, 'minutes') >= minutes;\r\n\t}\r\n\r\n\t/**\r\n\t * It could be 11PM yesterday, and 1 AM today. Actually based on local today.\r\n\t */\r\n\tstatic olderThan1Day(dtUtc: Date | null | undefined): boolean {\r\n\t\treturn DateFunc.getDayAgeUtc(dtUtc) > 0;\r\n\t}\r\n\r\n\tstatic getHourAge(d: Date) {\r\n\t\tconst m = moment(d);\r\n\t\treturn moment().diff(m, 'hours');\r\n\t}\r\n\r\n\tstatic getHourAgeUtc(dtUtc: Date | null | undefined) {\r\n\t\tconst m = moment.utc(dtUtc);\r\n\t\treturn moment.utc().diff(m, 'hours');\r\n\t}\r\n\r\n\t/**\r\n\t * Compare utc date with utc now.\r\n\t * @param dtUtc\r\n\t */\r\n\tstatic getDayAgeUtc(dtUtc: Date | null | undefined) {\r\n\t\tconst m = moment.utc(dtUtc);\r\n\t\treturn moment.utc().diff(m, 'days');\r\n\t}\r\n\r\n\t/**\r\n\t * How many years from now.\r\n\t * @param d \r\n\t * @returns \r\n\t */\r\n\tstatic getAge(d: Date) {\r\n\t\tconst m = moment(d);\r\n\t\treturn moment().diff(m, 'years');\r\n\t}\r\n\r\n\t/**\r\n\t * Year of date.\r\n\t * @param d \r\n\t * @returns \r\n\t */\r\n\tstatic getYear(d: Date) {\r\n\t\tconst m = moment(d);\r\n\t\treturn m.year();\r\n\t}\r\n\r\n\tstatic getUtcNow(): Date {\r\n\t\treturn moment.utc().toDate();\r\n\t}\r\n\r\n\tstatic addMinutes(d: Date, m: number): Date {\r\n\t\treturn moment(d).add(m, 'm').toDate();\r\n\t}\r\n\r\n\tstatic addMonth(d: Date, m: number): Date {\r\n\t\treturn moment(d).add(m, 'M').toDate();\r\n\t}\r\n\r\n\tstatic getDuration(d1: Date, d2: Date) {\r\n\t\tconst md1 = moment(d1);\r\n\t\tconst md2 = moment(d2);\r\n\t\treturn moment.duration(md2.diff(md1));\r\n\t}\r\n\r\n\t/**\r\n\t * Convert minutes from midnight to HH:mm text\r\n\t * @param mins\r\n\t */\r\n\tstatic getHMFromMins(mins: number): string {\r\n\t\t// do not include the first validation check if you want, for example,\r\n\t\t// getTimeFromMins(1530) to equal getTimeFromMins(90) (i.e. mins rollover)\r\n\t\tif (mins >= 24 * 60 || mins < 0) {\r\n\t\t\tthrow new RangeError('Valid input should be greater than or equal to 0 and less than 1440.');\r\n\t\t}\r\n\t\tconst h = mins / 60 | 0,\r\n\t\t\tm = mins % 60 | 0;\r\n\t\treturn moment.utc().hours(h).minutes(m).format('HH:mm');\r\n\t}\r\n\r\n\tstatic getMinutesSinceMidnight(d: Date | null | undefined) {\r\n\t\tconst m = moment(d);\r\n\t\tconst midnight = moment(d).startOf('day'); //Mutates the original moment by setting it to the start of a unit of time. So I have better not to use m which wil be changed by calling this function\r\n\t\treturn m.diff(midnight, 'minutes');\r\n\t}\r\n\r\n\tstatic getMinutesBetween(start: Date | null | undefined, end: Date | null | undefined) {\r\n\t\tconst m = moment(start);\r\n\t\tconst m2 = moment(end);\r\n\t\treturn m2.diff(m, 'minutes');\r\n\t}\r\n\r\n\t/**\r\n\t * Parse json string with date serialized into string, and get proper date object back\r\n\t * @param s\r\n\t */\r\n\tstatic dateSafeJsonParse(s: string) {\r\n\t\treturn JSON.parse(s, this.dateReviver);\r\n\t}\r\n\r\n\tprivate static dateReviver(key: string, value: any) {\r\n\t\tif (DateFunc.isSerializedDate(value)) {\r\n\t\t\treturn (new Date(value));\r\n\t\t}\r\n\r\n\t\t// If it's not a date-string, we want to return the value as-is. If we fail to return\r\n\t\t// a value, it will be omitted from the resultant data structure.\r\n\t\treturn (value);\r\n\r\n\t}\r\n\r\n\r\n\t// I determine if the given value is a string that matches the serialized-date pattern.\r\n\tprivate static isSerializedDate(value: any): boolean {\r\n\t\t// Dates are serialized in TZ format, example: '1981-12-20T04:00:14.000Z'.\r\n\t\tconst datePattern = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$/;\r\n\t\treturn (DateFunc.isString(value) && datePattern.test(value));\r\n\t}\r\n\r\n\r\n\t// I determine if the given value is a String.\r\n\tprivate static isString(value: any): boolean {\r\n\t\treturn ({}.toString.call(value) === '[object String]');\r\n\t}\r\n\r\n\tstatic dateSafeParse(s: string | Date) {\r\n\t\tconst m = moment(s);\r\n\t\treturn m.toDate();\r\n\t}\r\n\r\n\tstatic composeDateWithMinutes(d: Date, minute: number): Date {\r\n\t\tconst m = moment(d);\r\n\t\tconst midnight = moment(d).startOf('day'); // Mutates the original moment by setting it to the start of a unit of time. So I have better not to use m which wil be changed by calling this function\r\n\t\tmidnight.add(minute, 'minutes');\r\n\t\treturn midnight.toDate();\r\n\t}\r\n\r\n\t/**\r\n\t * Safe compare since date data may be considered as string rather than date.\r\n\t * @param d1\r\n\t * @param d2\r\n\t */\r\n\tstatic compare(d1: Date | undefined, d2: Date | undefined): number {\r\n\t\tif (!d1 && !d2) {\r\n\t\t\treturn 0;\r\n\t\t}\r\n\r\n\t\tif (!d1) {\r\n\t\t\treturn -NaN\r\n\t\t}\r\n\r\n\t\tif (!d2) {\r\n\t\t\treturn NaN;\r\n\t\t}\r\n\r\n\t\tconst dd1 = (new Date(d1)).valueOf();\r\n\t\tconst dd2 = (new Date(d2)).valueOf();\r\n\t\treturn dd1 - dd2;\r\n\t}\r\n}\r\n\r\n"]}

package/esm2020/_func/htmlPrintFunc.mjs

@@ -0,0 +1,45 @@
+export class HtmlPrintFunc {
+    /**
+     * Print with CSS for internal reports
+     * @param htmlTags
+     * @param cssUrl
+     */
+    static printWithCSS(htmlTags, cssUrl) {
+        if (window) {
+            const htmlToPrint = `<html><head>
+<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no"/>
+<link rel="stylesheet" type="text/css" href="${cssUrl}" media="screen,print"/>
+</head><body onload="window.print()">${htmlTags}</body></html>`;
+            const popup = window.open('', '_blank', 'width=1024,height=768');
+            popup?.document.open();
+            popup?.document.write(htmlToPrint);
+            popup?.document.close();
+        }
+        return true;
+    }
+    /**
+     * Print for external documents.
+     * @param htmlTags
+     */
+    static print(htmlTags) {
+        if (window) {
+            const htmlToPrint = `<html><head>
+<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no"/>
+</head><body onload="window.print()">${htmlTags}</body></html>`;
+            const popup = window.open('', '_blank', 'width=1024,height=768');
+            popup?.document.open();
+            popup?.document.write(htmlToPrint);
+            popup?.document.close();
+        }
+        return true;
+    }
+    /**
+     * Print image url through html img.
+     * @param url
+     */
+    static printImage(url) {
+        const imageTags = `<img src="${url}" alt="Image from URL"/>`;
+        HtmlPrintFunc.print(imageTags);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/_func/index.mjs

@@ -0,0 +1,11 @@
+export * from './addressFunc';
+export * from './authentication.service';
+export * from './currencyFunc';
+export * from './dateFunc';
+export * from './htmlPrintFunc';
+export * from './javascriptFunc';
+export * from './jsonFunc';
+export * from './stringAusFunc';
+export * from './stringFunc';
+export * from './uuidFunc';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9ubWNlLWZ1bmMvc3JjL19mdW5jL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYWRkcmVzc0Z1bmMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2F1dGhlbnRpY2F0aW9uLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2N1cnJlbmN5RnVuYyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZGF0ZUZ1bmMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2h0bWxQcmludEZ1bmMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2phdmFzY3JpcHRGdW5jJztcclxuZXhwb3J0ICogZnJvbSAnLi9qc29uRnVuYyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc3RyaW5nQXVzRnVuYyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc3RyaW5nRnVuYyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vdXVpZEZ1bmMnO1xyXG5cclxuXHJcbiJdfQ==

package/esm2020/_func/javascriptFunc.mjs

@@ -0,0 +1,17 @@
+export class JavaScriptFunc {
+    /**
+     * Some business functions depend on external JavaScript libraries. Lazy loading of respective business modules is good,
+     * and this function supports lazy loading of JS libraries.
+     * @param scriptUrl
+     * @returns Promise for subsequent JS function calls.
+     */
+    static loadExternalScript(scriptUrl) {
+        return new Promise((resolve, reject) => {
+            const scriptElement = document.createElement('script');
+            scriptElement.src = scriptUrl;
+            scriptElement.onload = resolve;
+            document.body.appendChild(scriptElement);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamF2YXNjcmlwdEZ1bmMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9ubWNlLWZ1bmMvc3JjL19mdW5jL2phdmFzY3JpcHRGdW5jLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxjQUFjO0lBQzFCOzs7OztPQUtHO0lBQ0gsTUFBTSxDQUFDLGtCQUFrQixDQUFDLFNBQWlCO1FBQzFDLE9BQU8sSUFBSSxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUU7WUFDdEMsTUFBTSxhQUFhLEdBQUcsUUFBUSxDQUFDLGFBQWEsQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUN2RCxhQUFhLENBQUMsR0FBRyxHQUFHLFNBQVMsQ0FBQztZQUM5QixhQUFhLENBQUMsTUFBTSxHQUFHLE9BQU8sQ0FBQztZQUMvQixRQUFRLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxhQUFhLENBQUMsQ0FBQztRQUMxQyxDQUFDLENBQUMsQ0FBQztJQUNKLENBQUM7Q0FDRCIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBKYXZhU2NyaXB0RnVuYyB7XHJcblx0LyoqXHJcblx0ICogU29tZSBidXNpbmVzcyBmdW5jdGlvbnMgZGVwZW5kIG9uIGV4dGVybmFsIEphdmFTY3JpcHQgbGlicmFyaWVzLiBMYXp5IGxvYWRpbmcgb2YgcmVzcGVjdGl2ZSBidXNpbmVzcyBtb2R1bGVzIGlzIGdvb2QsIFxyXG5cdCAqIGFuZCB0aGlzIGZ1bmN0aW9uIHN1cHBvcnRzIGxhenkgbG9hZGluZyBvZiBKUyBsaWJyYXJpZXMuXHJcblx0ICogQHBhcmFtIHNjcmlwdFVybCBcclxuXHQgKiBAcmV0dXJucyBQcm9taXNlIGZvciBzdWJzZXF1ZW50IEpTIGZ1bmN0aW9uIGNhbGxzLlxyXG5cdCAqL1xyXG5cdHN0YXRpYyBsb2FkRXh0ZXJuYWxTY3JpcHQoc2NyaXB0VXJsOiBzdHJpbmcpIHtcclxuXHRcdHJldHVybiBuZXcgUHJvbWlzZSgocmVzb2x2ZSwgcmVqZWN0KSA9PiB7XHJcblx0XHRcdGNvbnN0IHNjcmlwdEVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTtcclxuXHRcdFx0c2NyaXB0RWxlbWVudC5zcmMgPSBzY3JpcHRVcmw7XHJcblx0XHRcdHNjcmlwdEVsZW1lbnQub25sb2FkID0gcmVzb2x2ZTtcclxuXHRcdFx0ZG9jdW1lbnQuYm9keS5hcHBlbmRDaGlsZChzY3JpcHRFbGVtZW50KTtcclxuXHRcdH0pO1xyXG5cdH1cclxufVxyXG4iXX0=

package/esm2020/_func/jsonFunc.mjs

@@ -0,0 +1,67 @@
+import { DateFunc } from './dateFunc';
+/**
+ * Basic JSON functions
+ */
+export class JsonFunc {
+    /**
+     *
+     * @param array Group by a property of array element.
+     * @param propertyName
+     * @returns
+     */
+    static groupBy(array, propertyName) {
+        return array.reduce(function (acc, obj) {
+            const key = obj[propertyName];
+            if (!acc[key]) {
+                acc[key] = [];
+            }
+            acc[key].push(obj);
+            return acc;
+        }, {});
+    }
+    /**
+     * Group by a date property. The key is always of string type and representing milliseconds.
+     * The client should convert the string to number.
+     * Angular date pipe could actually consume such string without explicitly converting to number.
+     * @param array
+     * @param propertyName
+     */
+    static groupByDate(array, propertyName) {
+        return array.reduce(function (acc, obj) {
+            const key = DateFunc.dateTimeUtcToLocalDateNumber(obj[propertyName]);
+            if (!acc[key]) {
+                acc[key] = [];
+            }
+            acc[key].push(obj);
+            return acc;
+        }, {});
+    }
+    /**
+     * Remove null or empty fields including those in nested objects.
+     * This is useful for reducing payload of AJAX serialization.
+     * @param obj
+     */
+    static removeNullOrEmptyFields(obj) {
+        for (const f in obj) {
+            let p = obj[f];
+            if (p === null || p === '') {
+                delete obj[f];
+            }
+            else if (typeof p === 'object' && p !== null) {
+                this.removeNullOrEmptyFields(p);
+            }
+        }
+    }
+    /**
+     *
+     * @param obj Remove null fields of object at only the 1st level.
+     */
+    static removeNullFields(obj) {
+        for (const f in obj) {
+            if (obj[f] === null) {
+                delete obj[f];
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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