nmce-func 1.3.2 → 1.4.1

package/fesm2022/nmce-func.mjs

@@ -1,8 +1,4 @@
-import * as i0 from '@angular/core';
-import { Injectable, Inject } from '@angular/core';
-import { map } from 'rxjs/operators';
-import * as i1 from '@angular/common/http';
-import moment from 'moment';
+import { DateTime, Settings, Duration } from 'luxon';
 import { v4 } from 'uuid';
 
 class AddressFunc {
@@ -54,67 +50,26 @@ class AddressFunc {
     }
 }
 
-/**
- * Login and saving tokens in sessionStorage.
- * App needs to provide constant 'auth.tokenUrl'.
- */
-class AuthenticationService {
-    authUri;
-    http;
-    username;
-    constructor(authUri, http) {
-        this.authUri = authUri;
-        this.http = http;
-    }
-    /**
-     * Login and save tokens to sessionStorage then return an observable.
-     * @param username
-     * @param password
-     */
-    login(username, password, headers) {
-        const body = 'username=' + username + '&password=' + password + '&grant_type=password';
-        const contentTypeHeader = { 'content-type': 'application/x-www-form-urlencoded; charset=UTF-8' };
-        const mergedHeaders = headers ? { ...contentTypeHeader, ...headers } : contentTypeHeader;
-        const options = { headers: mergedHeaders };
-        return this.http.post(this.authUri, body, options)
-            .pipe(map(response => {
-            //sessionStorage.setItem('access_token', response.access_token); The client code is response to doing these.
-            //sessionStorage.setItem('expires_in', response.expires_in.toString());
-            //sessionStorage.setItem('token_type', response.token_type);
-            //sessionStorage.setItem('issued', response.issued);
-            //sessionStorage.setItem('expires', response.expires); // often up to 2 weeks by default in Asp.net identity 2.
-            this.username = response.username;
-            //APP_STATUSES.userName = this.userName;
-            return response;
-        }));
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: AuthenticationService, deps: [{ token: 'auth.tokenUrl' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: AuthenticationService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: AuthenticationService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['auth.tokenUrl']
-                }] }, { type: i1.HttpClient }] });
-
 /**
  * Currency calculations. Undefined input of number is considered zero, just like null.
+ * Simple functions for currency before you decide to use more comprehensive ones:
+ * https://github.com/scurker/currency.js
+ * https://github.com/dinerojs/dinero.js Up to date and popular
  */
 class CurrencyFunc {
     static DECIMAL_SEPARATOR = '.';
     static THOUSANDS_SEPARATOR = ',';
     static PADDING = '000000';
     /**
-     *
+     * Banker rounding
      * @param num
-     * @param decimalPlaces default 0
+     * @param decimalPlace default 0
      */
-    static bankerRound(num, decimalPlaces) {
+    static bankerRound(num, decimalPlace) {
         if (!num) {
             return 0;
         }
-        const d = decimalPlaces || 0;
+        const d = decimalPlace || 0;
         const m = Math.pow(10, d);
         const n = +(d ? num * m : num).toFixed(8); // Avoid rounding errors
         const i = Math.floor(n), f = n - i;
@@ -122,48 +77,57 @@ class CurrencyFunc {
         const r = (f > 0.5 - e && f < 0.5 + e) ?
             ((i % 2 === 0) ? i : i + 1) : Math.round(n);
         return d ? r / m : r;
+        // http://stackoverflow.com/questions/3108986/gaussian-bankers-rounding-in-javascript
     }
+    /**
+     * Banker rounding to 5 cents
+     * @param num
+     * @returns
+     */
     static bankerRoundTo5cents(num) {
         if (!num) {
             return 0;
         }
-        const r = this.bankerRound(Math.ceil(num * 20 - 0.5) / 20, 2);
+        const r = this.bankerRound(Math.round(num / 0.05) * 0.05, 2);
         return r;
     }
-    static ceilTo5cents(num) {
-        if (!num) {
-            return 0;
-        }
-        const r = this.bankerRound(Math.ceil(num * 20) / 20, 4);
-        const roundup = Math.ceil(r * 10000) / 10000;
-        return roundup;
-    }
-    static transformCurrency(value, fractionSize = 2) {
-        let [integer, fraction = ''] = (value || '').toString()
-            .split(this.DECIMAL_SEPARATOR);
-        fraction = fractionSize > 0
-            ? this.DECIMAL_SEPARATOR + (fraction + this.PADDING).substring(0, fractionSize)
-            : '';
-        integer = integer.replace(/\B(?=(\d{3})+(?!\d))/g, this.THOUSANDS_SEPARATOR);
-        return integer + fraction;
-    }
-    static parseCurrency(value, fractionSize = 2) {
-        let [integer, fraction = ''] = (value || '').split(this.DECIMAL_SEPARATOR);
-        integer = integer.replace(new RegExp(this.THOUSANDS_SEPARATOR, 'g'), '');
-        fraction = parseInt(fraction, 10) > 0 && fractionSize > 0
-            ? this.DECIMAL_SEPARATOR + (fraction + this.PADDING).substring(0, fractionSize)
-            : '';
-        return integer + fraction;
-    }
+    // static transformCurrency(value: number | string | undefined, fractionSize: number = 2): string { In favour of dinerojs
+    // 	let [integer, fraction = ''] = (value || '').toString()
+    // 		.split(this.DECIMAL_SEPARATOR);
+    // 	fraction = fractionSize > 0
+    // 		? this.DECIMAL_SEPARATOR + (fraction + this.PADDING).substring(0, fractionSize)
+    // 		: '';
+    // 	integer = integer.replace(/\B(?=(\d{3})+(?!\d))/g, this.THOUSANDS_SEPARATOR);
+    // 	return integer + fraction;
+    // }
+    // static parseCurrency(value: string | undefined, fractionSize: number = 2): string {
+    // 	let [integer, fraction = ''] = (value || '').split(this.DECIMAL_SEPARATOR);
+    // 	integer = integer.replace(new RegExp(this.THOUSANDS_SEPARATOR, 'g'), '');
+    // 	fraction = parseInt(fraction, 10) > 0 && fractionSize > 0
+    // 		? this.DECIMAL_SEPARATOR + (fraction + this.PADDING).substring(0, fractionSize)
+    // 		: '';
+    // 	return integer + fraction;
+    // }
     //http://stackoverflow.com/questions/2998784/how-to-output-integers-with-leading-zeros-in-javascript
     static pad(num, size) {
-        num = null;
-        let s = num + '';
+        if (num == null) {
+            return '';
+        }
+        if (num === 0) {
+            return '0';
+        }
+        const numText = num.toString();
+        let s = numText + '';
         while (s.length < size) {
             s = '0' + s;
         }
         return s;
     }
+    /**
+     * Sum array of numbers
+     * @param ns
+     * @returns
+     */
     static sum(ns) {
         const r = ns.reduce((a, b) => (a ?? 0) + (b ?? 0), 0);
         return r;
@@ -171,100 +135,176 @@ class CurrencyFunc {
 }
 
 class DateFunc {
+    /**
+     * At runtime, there's no simple guarantee that the input is Date. Sometimes you codes expect date, but the response from the Web service may give you string or number.
+     * This function give you safe parse of date data from I/O, not of your control.
+     * If the data is invalid, throws RangeError or TypeError.
+     * @param dt
+     * @returns
+     */
+    static dateDataToDate(dt) {
+        if (dt instanceof Date) {
+            return dt;
+        }
+        if (typeof dt === 'string') {
+            const r = Date.parse(dt);
+            if (isNaN(r)) {
+                throw new RangeError('Invalid string for Date');
+            }
+            return new Date(r);
+        }
+        if (typeof dt === 'number') {
+            const rd = new Date(dt);
+            if (Number.isNaN(rd.valueOf())) {
+                throw new RangeError('Invalid number for Date');
+            }
+            return rd;
+        }
+        throw new TypeError('Expect Date, string or number');
+    }
+    /**
+     * Similar to dateDataToDate, but allow null and defined semantically.
+     * @param dt
+     * @returns
+     */
+    static dateDataToDateOrNull(dt) {
+        if (dt instanceof Date) {
+            return dt;
+        }
+        if (typeof dt === 'string') {
+            const r = Date.parse(dt);
+            if (isNaN(r)) {
+                throw new RangeError('Invalid string for Date');
+            }
+            return new Date(r);
+        }
+        if (typeof dt === 'number') {
+            const rd = new Date(dt);
+            if (Number.isNaN(rd.valueOf())) {
+                throw new RangeError('Invalid number for Date');
+            }
+            return rd;
+        }
+        if (dt == null) {
+            return dt;
+        }
+        throw new TypeError('Expect Date, string or number');
+    }
     /**
      * 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.
+        if (dtUtc == null) {
+            return dtUtc;
         }
-        const localDt = DateFunc.dateTimeUtcToLocalDateTime(dtUtc);
+        const localDt = this.dateDataToDate(dtUtc);
         const localDNum = localDt.setHours(0, 0, 0, 0);
         return localDNum;
     }
     /**
      * Date only. However, the date may still be in UTC.
      * @param dtUtc
+     * @returns new Date object.
      */
     static dateTimeUtcToLocalDate(dtUtc) {
-        const localDt = DateFunc.dateTimeUtcToLocalDateTime(dtUtc);
-        const localD = localDt.setHours(0, 0, 0, 0);
-        return new Date(localD);
+        if (dtUtc == null) {
+            return dtUtc;
+        }
+        const localDt = this.dateDataToDate(dtUtc);
+        const localNum = localDt.setHours(0, 0, 0, 0);
+        return new Date(localNum);
     }
+    /**
+     * '2018-01-23T22:00:00Z' will become '2018-01-24' in Australia.
+     * @param dtUtc
+     * @returns  new Date object.
+     */
     static localISODateString(dtUtc) {
-        const dt = moment(dtUtc).local();
-        return dt.format('YYYY-MM-DD');
+        const dt = this.dateTimeUtcToLocalDate(dtUtc);
+        if (dt == null) {
+            return dt;
+        }
+        const d = DateTime.fromJSDate(dt);
+        return d.toISODate();
     }
     /**
-     * locate date ONLY (no time) to UTC date.
+     * local date ONLY (no time) to UTC date.
+     * The input could be a string of yyyy-MM-dd, or a Date Object.
+     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
+     * While the time value at the heart of a Date object is UTC, the basic methods to fetch the date and time
+     * or its components all work in the local (i.e. host system) time zone and offset.
      * @param dt if dt contain time info, it will become dt.setHours(0, 0, 0, 0)
      */
     static localDateToUtc(d) {
-        const dt = moment(d).toDate();
+        if (d == null) {
+            return d;
+        }
+        const dt = this.dateDataToDate(d);
         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();
+        const dateTime = DateTime.fromJSDate(this.dateDataToDate(dt));
+        return dateTime.endOf('week').toJSDate();
     }
     static getStartOfWeek(dt) {
-        return moment(dt).startOf('isoWeek').toDate();
+        const dateTime = DateTime.fromJSDate(this.dateDataToDate(dt));
+        return dateTime.startOf('week').toJSDate();
     }
     static getEndOfMonth(dt) {
-        //  return new Date(dt.getFullYear(), dt.getMonth() + 1, 0, 23, 59, 59, 999);
-        return moment(dt).endOf('month').toDate();
+        const dateTime = DateTime.fromJSDate(this.dateDataToDate(dt));
+        return dateTime.endOf('month').toJSDate();
     }
     static getStartOfMonth(dt) {
-        return moment(dt).startOf('month').toDate();
-    }
-    static getDaysBetweenDates(dt1, dt2) {
-        return this.getDaysBetween(dt1, dt2);
+        const dateTime = DateTime.fromJSDate(this.dateDataToDate(dt));
+        return dateTime.startOf('month').toJSDate();
     }
     static getEndOfDate(dt) {
-        return dt ? new Date(dt.setHours(23, 59, 59, 999)) :
-            new Date(this.now.setHours(23, 59, 59, 999));
+        const dateTime = DateTime.fromJSDate(this.dateDataToDate(dt));
+        return dateTime.endOf('day').toJSDate();
     }
     static getStartOfDate(dt) {
-        return moment(dt).startOf('day').toDate();
+        const dateTime = DateTime.fromJSDate(this.dateDataToDate(dt));
+        return dateTime.startOf('day').toJSDate();
     }
     static getEndOfToday() {
-        //	return new Date((new Date(Date.now())).setHours(23, 59, 59, 999));
-        return moment(Date.now()).endOf('day').toDate();
+        return this.getEndOfDate(Date.now());
     }
     static getStartOfToday() {
-        //	return new Date((new Date(Date.now())).setHours(0, 0, 0, 0));
-        return moment(Date.now()).startOf('day').toDate();
+        return this.getStartOfDate(Date.now());
+    }
+    static getDaysBetween(d1, d2) {
+        const dm1 = DateTime.fromJSDate(this.dateDataToDate(d1));
+        const dm2 = DateTime.fromJSDate(this.dateDataToDate(d1));
+        return dm2.diff(dm1, 'days').days;
     }
     //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 addDays(dt, days) {
+        const dat = DateTime.fromJSDate(this.dateDataToDate(dt));
+        const r = dat.plus({ days: days });
+        return r.toJSDate();
+    }
+    static addMonths(dt, months) {
+        const dat = DateTime.fromJSDate(this.dateDataToDate(dt));
+        const r = dat.plus({ months: months });
+        return r.toJSDate();
+    }
+    static addYears(dt, years) {
+        const dat = DateTime.fromJSDate(this.dateDataToDate(dt));
+        const r = dat.plus({ years: years });
+        return r.toJSDate();
+    }
+    static addHours(dt, hours) {
+        const dat = DateTime.fromJSDate(this.dateDataToDate(dt));
+        const r = dat.plus({ hours: hours });
+        return r.toJSDate();
     }
-    static subtractDays(dt, days = 0) {
-        const dat = moment(dt);
-        dat.subtract(days, 'days');
-        return dat.toDate();
+    static addMinutes(dt, minutes) {
+        const dat = DateTime.fromJSDate(this.dateDataToDate(dt));
+        const r = dat.plus({ minutes: minutes });
+        return r.toJSDate();
     }
     /**
      * Start of today
@@ -275,104 +315,119 @@ class DateFunc {
     static get now() {
         return new Date(Date.now());
     }
+    /**
+     * From now, next 5 minute mark. For example 2:23:44 will be 2:25:00;
+     * @returns
+     */
     static getNext5MinuteMark() {
-        const m = moment().set('second', 0).set('millisecond', 0);
-        const minute = m.minute();
+        const m = DateTime.now().set({ second: 0, millisecond: 0 });
+        const minute = m.minute;
         const mod = minute % 5;
         if (mod) {
             const delta = 5 - mod;
-            return m.add(delta, 'm').toDate();
+            return m.plus({ minutes: delta }).toJSDate();
         }
-        return m.toDate();
+        return m.toJSDate();
     }
     static getYMD(d) {
-        return moment(d).format('YYYYMMDD');
+        const dt = DateTime.fromJSDate(this.dateDataToDate(d));
+        return dt.toFormat('yyyyMMdd');
     }
     static getDMYWithSlash(d) {
-        return moment(d).format('DD/MM/YYYY');
+        const dt = DateTime.fromJSDate(this.dateDataToDate(d));
+        return dt.toFormat('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');
+        const dt = DateTime.fromJSDate(this.dateDataToDate(d));
+        return dt.toFormat('dd/MM/yyyy HH:mm');
     }
     /**
-     * In 24 hour format
-     * @param dtUtc
+     *
+     * @param dtUtc In 24 hour format, and the date separator depending on the system or Luxon default locale
+     * @returns
      */
-    static getLocalDMYHmWithSlash(dtUtc) {
-        const d = DateFunc.dateTimeUtcToLocalDateTime(dtUtc);
-        return moment(d).format('DD/MM/YYYY HH:mm');
+    static getDateTime24Simple(dtUtc) {
+        if (dtUtc == null) {
+            return dtUtc;
+        }
+        const d = this.dateDataToDate(dtUtc);
+        const dt = DateTime.fromJSDate(d);
+        return dt.toLocaleString(DateTime.DATE_SHORT) + ' ' + dt.toLocaleString(DateTime.TIME_24_SIMPLE);
+    }
+    static setDefaultLocale(locale) {
+        Settings.defaultLocale = locale;
+    }
+    static getDefaultLocale() {
+        return Settings.defaultLocale;
+    }
+    static setDefaultZone(zone) {
+        Settings.defaultZone = zone;
+    }
+    static getDefaultZone() {
+        return Settings.defaultZone.name;
+    }
+    static isZoneValid() {
+        return Settings.defaultZone.isValid;
     }
     /**
-     * Offset minutes comparing with today
+     * For example, in AEST, it is -600.
+     * @returns
      */
-    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');
+    static getLocalTimezoneOffset() {
+        const dt = new Date(Date.now());
+        return dt.getTimezoneOffset();
     }
     /**
      * 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();
+        const dt = DateTime.fromJSDate(this.dateDataToDate(dtUtc));
+        return dt.hour;
     }
     static getMinute(dtUtc) {
-        const m = moment(dtUtc);
-        return m.minutes();
+        const dt = DateTime.fromJSDate(this.dateDataToDate(dtUtc));
+        return dt.minute;
     }
-    static composeDateTime(dt, h = 0, minute = 0) {
-        const mt = moment(dt);
-        return new Date(mt.toDate().setHours(h, minute, 0, 0));
+    static GetHM(dtUtc) {
+        const dt = DateTime.fromJSDate(this.dateDataToDate(dtUtc));
+        return { h: dt.hour, m: dt.minute };
     }
-    static olderThan24Hours(d) {
-        const m = moment(d);
-        return moment().diff(m, 'hours') >= 24;
+    static composeDateTime(dt, h = 0, minute = 0, second = 0) {
+        return new Date(this.dateDataToDate(dt).setHours(h, minute, second, 0));
     }
-    static olderThan24HoursUtc(dtUtc) {
-        return DateFunc.getHourAgeUtc(dtUtc) >= 24;
+    static olderThan24Hours(d) {
+        const m = DateTime.fromJSDate(this.dateDataToDate(d));
+        return DateTime.now().diff(m, 'hours') >= Duration.fromISO('PT24H');
     }
     static olderThanHours(d, hours) {
-        const m = moment(d);
-        return moment().diff(m, 'hours') >= hours;
-    }
-    static olderThanHoursUtc(dtUtc, hours) {
-        return DateFunc.getHourAgeUtc(dtUtc) >= hours;
+        const m = DateTime.fromJSDate(this.dateDataToDate(d));
+        const diff = DateTime.now().diff(m, 'hours');
+        const duration = Duration.fromISO(`PT${hours}H`);
+        console.debug('diff: ' + diff.hours + '   duration: ' + duration.hours);
+        return diff.hours >= duration.hours;
     }
     static olderThanMinutes(d, minutes) {
-        const m = moment(d);
-        return moment().diff(m, 'minutes') >= minutes;
+        const m = DateTime.fromJSDate(this.dateDataToDate(d));
+        return DateTime.now().diff(m, 'minutes') >= Duration.fromMillis(minutes * 60 * 1000);
     }
     /**
      * It could be 11PM yesterday, and 1 AM today. Actually based on local today.
      */
     static olderThan1Day(dtUtc) {
-        return DateFunc.getDayAgeUtc(dtUtc) > 0;
+        return DateFunc.getDayAge(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');
+        const m = DateTime.fromJSDate(this.dateDataToDate(d));
+        return DateTime.now().diff(m, 'hours').hours;
     }
     /**
-     * Compare utc date with utc now.
+     * Compare date with now.
      * @param dtUtc
      */
-    static getDayAgeUtc(dtUtc) {
-        const m = moment.utc(dtUtc);
-        return moment.utc().diff(m, 'days');
+    static getDayAge(d) {
+        const m = DateTime.fromJSDate(this.dateDataToDate(d));
+        return DateTime.now().diff(m, 'days').days;
     }
     /**
      * How many years from now.
@@ -380,108 +435,29 @@ class DateFunc {
      * @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));
+        const m = DateTime.fromJSDate(this.dateDataToDate(d));
+        return DateTime.now().diff(m, 'years').years;
     }
     /**
      * Convert minutes from midnight to HH:mm text
-     * @param mins
+     * @param minutes
      */
-    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) {
+    static getHMFromMins(minutes) {
+        if (minutes >= 24 * 60 || minutes < 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');
+        const h = minutes / 60 | 0, m = minutes % 60 | 0;
+        return DateTime.utc().set({ hour: h, minute: m }).toFormat('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');
+        const dt = DateTime.fromJSDate(this.dateDataToDate(d));
+        const midnight = dt.startOf('day');
+        return dt.diff(midnight, 'minutes').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;
+        const m = DateTime.fromJSDate(this.dateDataToDate(start));
+        const m2 = DateTime.fromJSDate(this.dateDataToDate(end));
+        return m2.diff(m, 'minutes').minutes;
     }
 }
 
@@ -493,9 +469,9 @@ class HtmlPrintFunc {
      */
     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"/>
+            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();
@@ -510,8 +486,8 @@ class HtmlPrintFunc {
      */
     static print(htmlTags) {
         if (window) {
-            const htmlToPrint = `<html><head>
-<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no"/>
+            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();
@@ -581,10 +557,12 @@ class JsonFunc {
     static groupByDate(array, propertyName) {
         return array.reduce(function (acc, obj) {
             const key = DateFunc.dateTimeUtcToLocalDateNumber(obj[propertyName]);
-            if (!acc[key]) {
-                acc[key] = [];
+            if (key != null) {
+                if (!acc[key]) {
+                    acc[key] = [];
+                }
+                acc[key].push(obj);
             }
-            acc[key].push(obj);
             return acc;
         }, {});
     }
@@ -910,14 +888,12 @@ class StringFunc {
     }
 }
 
-// import { v5 as uuid } from 'uuid/v5 causes ERROR in src / app / _func / helperFunc.ts(1, 10): error TS2305: Module '"C:/VSProjects/ApsCloudTrunk/APS.WebPos.NGCli/NGSource/node_modules/@types/uuid/v5"' has no exported member 'v5'
 // https://github.com/DefinitelyTyped/DefinitelyTyped/pull/28439
 class UuidFunc {
     /**
      * 36 UUID string including 4 hyphens. MySql stores GUID as 36 bytes anyway rather than 16bytes.
      */
     static newUUID() {
-        //		return uuid('medilink.com.au', 'apscloud');
         return v4();
     }
     static newUUIDStartWith0() {
@@ -934,5 +910,5 @@ class UuidFunc {
  * Generated bundle index. Do not edit.
  */
 
-export { AddressFunc, AuthenticationService, CurrencyFunc, DateFunc, HtmlPrintFunc, JavaScriptFunc, JsonFunc, StringAusFunc, StringFunc, UuidFunc };
+export { AddressFunc, CurrencyFunc, DateFunc, HtmlPrintFunc, JavaScriptFunc, JsonFunc, StringAusFunc, StringFunc, UuidFunc };
 //# sourceMappingURL=nmce-func.mjs.map