nmce-func 0.0.4 → 0.0.8

package/fesm2015/nmce-func.mjs

@@ -0,0 +1,931 @@
+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 { v4 } from 'uuid';
+
+class AddressFunc {
+    /**
+     * Compose to one line separated by comma
+     * @param st1
+     * @param st2
+     * @param city
+     * @param state
+     * @param postcode
+     */
+    static composeOneLineAddress(st1, st2, city, state, postcode) {
+        return AddressFunc.composeAddress(st1, st2, city, state, postcode, ', ');
+    }
+    /**
+     * Compose to multiple separated by \n
+     * @param st1
+     * @param st2
+     * @param city
+     * @param state
+     * @param postcode
+     */
+    static composeMultiLineAddress(st1, st2, city, state, postcode) {
+        return AddressFunc.composeAddress(st1, st2, city, state, postcode, '\n');
+    }
+    /**
+     * Compose with separator
+     * @param st1
+     * @param st2
+     * @param city
+     * @param state
+     * @param postcode
+     * @param sep
+     */
+    static composeAddress(st1, st2, city, state, postcode, sep) {
+        const r = (st1 ? (st1 + sep) : '') + (st2 ? (st2 + sep) : '') + (city ? (city + sep) : '') + (state ? (state + ' ') : '') + (postcode ? postcode : '');
+        return r;
+    }
+    static composeGoogleMapsAuUrl(st1, st2, city, state, country) {
+        const googleBaseUrl = 'https://www.google.com.au/maps?hl=en&q=';
+        const fff = (s) => {
+            if (!s) {
+                return '';
+            }
+            return '+' + encodeURIComponent(s.replace(' ', '+')) + ',';
+        };
+        const ss = fff(st1) + fff(st2) + fff(city) + fff(state) + fff(country);
+        return googleBaseUrl + ss;
+    }
+}
+
+/**
+ * Login and saving tokens in sessionStorage.
+ * App needs to provide constant 'auth.tokenUrl'.
+ */
+class AuthenticationService {
+    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) {
+        const body = 'username=' + username + '&password=' + password + '&grant_type=password';
+        const options = { headers: { 'content-type': 'application/x-www-form-urlencoded; charset=UTF-8' } };
+        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;
+        }));
+    }
+}
+AuthenticationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: AuthenticationService, deps: [{ token: 'auth.tokenUrl' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthenticationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: AuthenticationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: AuthenticationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['auth.tokenUrl']
+                    }] }, { type: i1.HttpClient }];
+    } });
+
+/**
+ * Currency calculations. Undefined input of number is considered zero, just like null.
+ */
+class CurrencyFunc {
+    /**
+     *
+     * @param num
+     * @param decimalPlaces default 0
+     */
+    static bankerRound(num, decimalPlaces) {
+        if (!num) {
+            return 0;
+        }
+        const d = decimalPlaces || 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;
+        const e = 1e-8; // Allow for rounding errors in f
+        const r = (f > 0.5 - e && f < 0.5 + e) ?
+            ((i % 2 === 0) ? i : i + 1) : Math.round(n);
+        return d ? r / m : r;
+    }
+    static bankerRoundTo5cents(num) {
+        if (!num) {
+            return 0;
+        }
+        const r = this.bankerRound(Math.ceil(num * 20 - 0.5) / 20, 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;
+    }
+    //http://stackoverflow.com/questions/2998784/how-to-output-integers-with-leading-zeros-in-javascript
+    static pad(num, size) {
+        num = null;
+        let s = num + '';
+        while (s.length < size) {
+            s = '0' + s;
+        }
+        return s;
+    }
+    static sum(ns) {
+        const r = ns.reduce((a, b) => (a !== null && a !== void 0 ? a : 0) + (b !== null && b !== void 0 ? b : 0), 0);
+        return r;
+    }
+}
+CurrencyFunc.DECIMAL_SEPARATOR = '.';
+CurrencyFunc.THOUSANDS_SEPARATOR = ',';
+CurrencyFunc.PADDING = '000000';
+
+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;
+    }
+}
+
+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 === null || popup === void 0 ? void 0 : popup.document.open();
+            popup === null || popup === void 0 ? void 0 : popup.document.write(htmlToPrint);
+            popup === null || popup === void 0 ? void 0 : 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 === null || popup === void 0 ? void 0 : popup.document.open();
+            popup === null || popup === void 0 ? void 0 : popup.document.write(htmlToPrint);
+            popup === null || popup === void 0 ? void 0 : 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);
+    }
+}
+
+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);
+        });
+    }
+}
+
+/**
+ * Basic JSON functions
+ */
+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];
+            }
+        }
+    }
+}
+
+/**
+ * String functions specific to Australia
+ */
+class StringAusFunc {
+    /**
+     * Validate medicare number
+     * @param n
+     * @returns validation error message
+     */
+    static validateMedicare(n) {
+        if (!n) {
+            return null;
+        }
+        if (n && n.length === 10) {
+            const matches = n.match(/^(\d{8})(\d)/);
+            if (!matches) {
+                return {
+                    code: 2, message: 'Medicare number should be all digit.'
+                };
+            }
+            const base = matches[1];
+            const checkDigit = matches[2];
+            const weights = [1, 3, 7, 9, 1, 3, 7, 9];
+            let sum = 0;
+            for (let i = 0; i < weights.length; i++) {
+                sum += parseInt(base[i], 10) * weights[i];
+            }
+            //console.debug(`sum: ${sum}  checkDigits: ${checkDigit}`);
+            const isValid = sum % 10 === parseInt(checkDigit, 10);
+            if (!isValid) {
+                return {
+                    code: 3, message: 'Checksum is incorrect.'
+                };
+            }
+        }
+        else {
+            return { code: 1, message: 'Length should be 10.' };
+        }
+        return null;
+    }
+    static validateMedicareProviderNumber(providerNumber) {
+        if (!providerNumber) {
+            return null;
+        }
+        if (!/^[0-9]{6}[0-9ABCDEFGHJKLMNPQRTUVWXY][ABFHJKLTWXY]/.test(providerNumber)) {
+            return { code: 1, message: 'Not matching provider number format.' };
+        }
+        const practiceLocationValues = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'T', 'U', 'V', 'W', 'X', 'Y'];
+        const remainderValues = ['Y', 'X', 'W', 'T', 'L', 'K', 'J', 'H', 'F', 'B', 'A'];
+        const stemWeights = [3, 5, 8, 4, 2, 1];
+        const stemNumbers = providerNumber.substr(0, 6).split('').map((char) => parseInt(char));
+        const practiceLoc = practiceLocationValues.findIndex((e) => e === providerNumber[6]);
+        const checksum = providerNumber[7];
+        const zipped = stemWeights.map((x, i) => [x, stemNumbers[i]]);
+        const sumWeights = zipped.map((y) => y[1] * y[0]).reduce((total, num) => total + num);
+        const remainder = (sumWeights + practiceLoc * 6) % 11;
+        const result = remainderValues[remainder];
+        const valid = result === checksum;
+        if (!valid) {
+            return { code: 2, message: 'Checksum is incorrect.' };
+        }
+        return null;
+    }
+    static validateDVAFileNumber(dva) {
+        if (!dva) {
+            return null;
+        }
+        const states = ['N', 'V', 'Q', 'S', 'W', 'T'];
+        const warCodes = [' ', 'X', 'KM', 'SR', 'SS', 'SM', 'SWP', 'AGX', 'BW', 'GW', 'CGW',
+            'P', 'PX', 'PAD', 'PAM', 'PCA', 'PCR', 'PCV', 'PMS', 'PSW', 'PWO', 'HKX', 'MAL',
+            'CN', 'CNX', 'IV', 'NF', 'NG', 'RD', 'RDX', 'SA', 'SAX', 'A',
+            'N', 'NX', 'NSW', 'NSM',
+            'BUR', 'CNK', 'CNS', 'FIJ', 'GHA', 'HKS', 'IND', 'KYA', 'MAU', 'MLS', 'MTX', 'MWI', 'NK', 'NGR', 'NRD', 'NSS', 'PK']; //British Commonwealth Countries - SP Eligibility
+        if (!states.includes(dva.charAt(0))) {
+            return { code: 1, message: 'State incorrect.' };
+        }
+        const ns = dva.match(/\d+/);
+        if (!ns) {
+            return { code: 2, message: 'No number.' };
+        }
+        const n = ns[0];
+        const idxOfN = dva.indexOf(n);
+        const warCode = dva.substring(1, idxOfN);
+        if (!warCodes.includes(warCode)) {
+            return { code: 3, message: 'War code invalid.' };
+        }
+        const lenOfN = n.length;
+        const lenOfWc = warCode.length;
+        if (lenOfN + lenOfWc > 7) {
+            return { code: 4, message: 'File number length should not be greater 7.' };
+        }
+        return null;
+    }
+    static validateTFN(n) {
+        if (!n) {
+            return null;
+        }
+        const tfn = n.replace(/\s+/g, '').replace(/[-]/g, '');
+        const isNumber = /^[0-9]+$/.test(tfn);
+        if (!isNumber) {
+            return { code: 1, message: 'Invalid TFN, only numbers are allowed.' };
+        }
+        const length = tfn.length;
+        if (length !== 9) {
+            return {
+                code: 2, message: 'Invalid TFN, must have 9 digits.'
+            };
+        }
+        const digits = tfn.split('').map(d => parseInt(d));
+        const sum = (digits[0] * 1)
+            + (digits[1] * 4)
+            + (digits[2] * 3)
+            + (digits[3] * 7)
+            + (digits[4] * 5)
+            + (digits[5] * 8)
+            + (digits[6] * 6)
+            + (digits[7] * 9)
+            + (digits[8] * 10);
+        const remainder = sum % 11;
+        const valid = remainder === 0;
+        if (!valid) {
+            return { code: 3, message: 'Checksum is incorrect.' };
+        }
+        return null;
+    }
+    static addWeighted(p, v, i) {
+        return p + v * StringAusFunc.weights[i];
+    }
+    static addAcnWeighted(p, v, i) {
+        return p + v * StringAusFunc.acnWeights[i];
+    }
+    static generateLookup() {
+        const ns = [];
+        for (let i = 0; i < 10; ++i) {
+            ns[i * 19 % 89] = i;
+        }
+        return ns;
+    }
+    static validateABN(abn) {
+        if (!abn) {
+            return null;
+        }
+        const digits = abn.replace(/[^\d]/g, '').split('').map(Number);
+        if (digits.length !== 11) {
+            return { code: 1, message: 'Expect 11-digit.' };
+        }
+        digits[0] -= 1;
+        const sum = digits.reduce(StringAusFunc.addWeighted, 0);
+        if (sum % 89 === 0) {
+            return null;
+        }
+        digits[0] += 1;
+        let sum1 = sum - digits[10] * StringAusFunc.weights[10];
+        let digit = StringAusFunc.suggestLookup[89 - sum1 % 89];
+        if (digit !== undefined) {
+            return {
+                code: 2,
+                message: 'Checksum1 is incorrect.'
+            };
+        }
+        else {
+            const sum2 = sum1 - digits[9] * StringAusFunc.weights[9];
+            for (let i = 0; i < 10; ++i) {
+                sum1 = sum2 + i * StringAusFunc.weights[9];
+                digit = StringAusFunc.suggestLookup[89 - sum1 % 89];
+                if (digit !== undefined) {
+                    return {
+                        code: 3,
+                        message: 'Checksum2 is incorrect.'
+                    };
+                }
+            }
+        }
+        return null;
+    }
+    static validateACN(acn) {
+        if (!acn) {
+            return null;
+        }
+        const digits = acn.replace(/[^\d]/g, '').split('').map(Number);
+        console.log(digits);
+        if (digits.length !== 9) {
+            return { code: 1, message: 'Expect 9-digit.' };
+        }
+        const sum = digits.slice(0, 8).reduce(StringAusFunc.addAcnWeighted, 0);
+        const lastDigit = 10 - sum % 10;
+        if (lastDigit === digits[8]) {
+            return null;
+        }
+        return {
+            code: 2,
+            message: 'Checksum is incorrect.'
+        };
+    }
+}
+//thanks to https://github.com/sidorares/australian-business-number/blob/0591475f5978fd122b472edcdc7efe6d96d56f26/index.js
+StringAusFunc.acnWeights = [8, 7, 6, 5, 4, 3, 2, 1];
+StringAusFunc.weights = [10, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
+StringAusFunc.suggestLookup = StringAusFunc.generateLookup();
+
+class StringFunc {
+    /**
+     * Up to 2 letters. For John Smith, returns JS, for Huang, Zijian, returns ZH
+     * @param s
+     */
+    static getAbbr(s) {
+        if (!s) {
+            return '';
+        }
+        const sArray = s.split(/[\s,]+/);
+        const comma = s.indexOf(',') >= 0;
+        if (sArray.length === 1) {
+            return sArray[0][0];
+        }
+        return comma ? sArray[1][0] + sArray[0][0] : sArray[0][0] + sArray[1][0];
+    }
+    /**
+     * A substring with line breaks replaced by space.
+     * @param s
+     * @param length
+     * @returns result, or empty string if the input is empty, null or undefined
+     */
+    static getOneLineDigest(s, length) {
+        if (!s) {
+            return '';
+        }
+        const ss = s.substring(0, length);
+        const st = ss.replace(new RegExp('\n', 'g'), ' ') + ((s.length > length) ? '...' : '');
+        return st.trim();
+    }
+    /**
+     * Remove line breaks and econde with encodeURI() so the data could be saved in Azure as meta. If the string is truncated, the return will have ... suffix.
+     * @param s
+     * @param length
+     * @returns result, or empty string if the input is empty, null or undefined
+     */
+    static getOneLineDigestOfHtml(s, length) {
+        if (!s) {
+            return '';
+        }
+        const ss = s.substring(0, length);
+        const st = ss.replace(new RegExp('\n', 'g'), ' ') + ((s.length > length) ? '...' : '');
+        return encodeURI(st.trim()); //need to encode in order to save as meta in Azure.
+    }
+    /**
+     * Pad number with zero
+     * @param num
+     * @param size
+     * @returns
+     */
+    static pad(num, size) {
+        if (num == null) {
+            return '';
+        }
+        let s = num + '';
+        while (s.length < size) {
+            s = '0' + s;
+        }
+        return s;
+    }
+    /**
+     * get plain text of HTML content
+     * @param s
+     * @returns result. If input is empty, null, or undefined, return the same.
+     */
+    static getHtmlPlainText(s) {
+        if (!s) {
+            return null;
+        }
+        const parser = new DOMParser();
+        const html = parser.parseFromString(s, 'text/html');
+        return html.body.textContent;
+    }
+    /**
+     *
+     * @param s
+     * @returns result. If input is empty, null, or undefined, return the same.
+     */
+    static capitalizeWords(s) {
+        if (!s) {
+            return s;
+        }
+        return s.replace(/(?:^|\s)\S/g, (a) => a.toUpperCase());
+    }
+    static validateEmail(email) {
+        if (!email) {
+            return true;
+        }
+        const re = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+        return re.test(email.toLowerCase());
+    }
+}
+
+// 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() {
+        const s = v4();
+        return '0000' + s.slice(4);
+    }
+}
+
+/*
+ * Public API Surface of nmce-func
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AddressFunc, AuthenticationService, CurrencyFunc, DateFunc, HtmlPrintFunc, JavaScriptFunc, JsonFunc, StringAusFunc, StringFunc, UuidFunc };
+//# sourceMappingURL=nmce-func.mjs.map