novo-elements 8.3.0 → 8.4.0-next.1

package/fesm2020/novo-elements-services.mjs

@@ -1,6 +1,8 @@
 import * as i0 from '@angular/core';
 import { Injector, Injectable, EventEmitter, LOCALE_ID, Optional, Inject } from '@angular/core';
-import { Helpers } from 'novo-elements/utils';
+import { Helpers, DateUtil, convertTokens } from 'novo-elements/utils';
+import { parse, format } from 'date-fns';
+import { MaskedRange, MaskedEnum } from 'imask';
 
 // NG2
 class ComponentUtils {
@@ -742,35 +744,79 @@ class DateFormatService {
         this.labels = labels;
     }
     getTimeMask(militaryTime) {
-        let mask = [/\d/, /\d/, /:/, /\d/, /\d/];
-        let timeFormatArray = [];
-        const timeFormat = this.labels.timeFormatPlaceholderAM.toLowerCase();
-        if (militaryTime) {
-            return mask;
-        }
-        else {
-            timeFormatArray = timeFormat.split('hh:mm');
-            if (timeFormatArray && timeFormatArray.length) {
-                mask = [];
-                for (const timeFormatPart of timeFormatArray) {
-                    if (timeFormatPart === '') {
-                        mask = mask.concat([/\d/, /\d|:/, /:|\d/, /\d|\w|\s/, /\d|\s|\w/]);
-                    }
-                    else if (timeFormatPart.length) {
-                        for (let i = 0; i < timeFormatPart.length; i++) {
-                            mask.push(/\s|\w|\d|\./);
-                        }
-                    }
-                }
-            }
-        }
+        const amFormat = this.labels.timeFormatAM.toUpperCase();
+        const pmFormat = this.labels.timeFormatPM.toUpperCase();
+        const mask = {
+            mask: Date,
+            pattern: militaryTime ? 'HH:mm' : 'hh:mm aa',
+            overwrite: true,
+            autofix: true,
+            lazy: false,
+            min: new Date(1970, 0, 1),
+            max: new Date(2030, 0, 1),
+            prepare(str) {
+                return str.toUpperCase();
+            },
+            format(date) {
+                return DateUtil.format(date, militaryTime ? 'HH:mm' : 'hh:mm A');
+            },
+            parse: (str) => {
+                const time = militaryTime ? str : this.convertTime12to24(str);
+                return DateUtil.parse(`${DateUtil.format(Date.now(), 'YYYY-MM-DD')}T${time}`);
+            },
+            blocks: {
+                HH: {
+                    mask: MaskedRange,
+                    placeholderChar: 'H',
+                    maxLength: 2,
+                    from: 0,
+                    to: 23,
+                },
+                hh: {
+                    mask: MaskedRange,
+                    placeholderChar: 'h',
+                    maxLength: 2,
+                    from: 1,
+                    to: 12,
+                },
+                mm: {
+                    mask: MaskedRange,
+                    placeholderChar: 'm',
+                    maxLength: 2,
+                    from: 0,
+                    to: 59,
+                },
+                aa: {
+                    mask: MaskedEnum,
+                    placeholderChar: 'x',
+                    enum: ['AM', 'PM', 'am', 'pm', amFormat, pmFormat],
+                },
+            },
+        };
         return mask;
     }
-    getDateMask() {
-        return [/\d/, /\d|\/|\.|\-/, /\/|\.|\-|\d/, /\d|\/|\.|\-/, /\d|\/|\.|\-/, /\d|\/|\.|\-/, /\d|\/|\.|\-/, /\d|\/|\.|\-/, /\d/, /\d/];
+    getDateMask(format) {
+        const mask = {
+            mask: Date,
+            pattern: 'm/`d/`Y',
+            overwrite: true,
+            autofix: 'pad',
+            min: new Date(1970, 0, 1),
+            max: new Date(2030, 0, 1),
+            prepare(str) {
+                return str.toUpperCase();
+            },
+            format(date) {
+                return DateUtil.format(date, format || 'MM/DD/YYYY');
+            },
+            parse: (str) => {
+                return DateUtil.parse(str);
+            },
+        };
+        return mask;
     }
     getDateTimeMask(militaryTime = false) {
-        return [...this.getDateMask(), /\,?/, /\s/, ...this.getTimeMask(militaryTime)];
+        return [this.getDateMask(), /\,?/, /\s/, this.getTimeMask(militaryTime)];
     }
     getTimePlaceHolder(militaryTime) {
         if (militaryTime) {
@@ -778,6 +824,60 @@ class DateFormatService {
         }
         return this.labels.timeFormatPlaceholderAM;
     }
+    parseCustomDateString(dateString, customFormat) {
+        let isInvalidDate = true;
+        let date = null;
+        if (!customFormat) {
+            customFormat = this.labels.dateFormatString();
+        }
+        customFormat = convertTokens(customFormat);
+        const [cleanDateString, cleanFormat] = this.removeNonstandardFormatCharacters(dateString, customFormat);
+        try {
+            date = parse(cleanDateString, cleanFormat, new Date(), {
+                useAdditionalWeekYearTokens: false
+            });
+            if (isNaN(date.getTime())) {
+                date = null;
+            }
+            else if (cleanDateString !== dateString) {
+                // Verify that this parse matches the original dateString through this format. If not, then something may have mismatched -
+                // in which case we consider the date to be invalid.
+                // For instance, if we parsed "Fri Oct 18, 2023" as " Oct 18 2023" (removing the duplicative day-of-week) then it
+                // would re-format as "Wed Oct 18 2023" and is an invalid date.
+                const reformattedDate = format(date, customFormat);
+                if (reformattedDate !== dateString) {
+                    date = null;
+                }
+                else {
+                    isInvalidDate = false;
+                }
+            }
+            else {
+                isInvalidDate = false;
+            }
+        }
+        catch (err) {
+            // ignore error - keep isInvalidDate true and date null
+        }
+        return [date, dateString, isInvalidDate];
+    }
+    /**
+     * Certain date format characters are considered nonstandard. We can still use them, but remove them for date parsing to avoid errors
+     * @param dateString
+     * @param format
+     * @returns date string and format in array, both having had their
+     */
+    removeNonstandardFormatCharacters(dateString, format) {
+        const bannedChars = /[iIRoPp]+/;
+        // remove quotes
+        format = format.replace(/['"]/g, '');
+        let match = null;
+        while ((match = bannedChars.exec(format)) != null) {
+            format = format.substring(0, match.index) + format.substring(match.index + match[0].length);
+            dateString = dateString.substring(0, match.index) + dateString.substring(match.index + match[0].length);
+        }
+        return [dateString, format];
+    }
     parseDateString(dateString) {
         let dateFormat = this.labels.dateFormatString();
         const dateFormatRegex = /(\w+)[\/|\.|\-](\w+)[\/|\.|\-](\w+)/gi;
@@ -787,7 +887,7 @@ class DateFormatService {
         let year;
         let month;
         let day;
-        let date = new Date();
+        let date = null;
         let isInvalidDate = true;
         if (Helpers.isEmpty(dateFormat)) {
             // Default to MM/dd/yyyy
@@ -820,10 +920,8 @@ class DateFormatService {
             const oneToken = /^(\d{1,4})$/.exec(dateString);
             const delimiter = /\w+(\/|\.|\-)\w+[\/|\.|\-]\w+/gi.exec(dateFormat);
             const dateStringWithDelimiter = dateString[dateString.length - 1].match(/\/|\.|\-/);
-            if (twoTokens && twoTokens.length === 3 && this.isValidDatePart(twoTokens[2], dateFormatTokens[2]) && !dateStringWithDelimiter) {
-                dateString = `${dateString}${delimiter[1]}`;
-            }
-            else if (oneToken && oneToken.length === 2 && this.isValidDatePart(oneToken[1], dateFormatTokens[1]) && !dateStringWithDelimiter) {
+            if ((twoTokens && twoTokens.length === 3 && this.isValidDatePart(twoTokens[2], dateFormatTokens[2]) && !dateStringWithDelimiter) ||
+                (oneToken && oneToken.length === 2 && this.isValidDatePart(oneToken[1], dateFormatTokens[1]) && !dateStringWithDelimiter)) {
                 dateString = `${dateString}${delimiter[1]}`;
             }
         }
@@ -834,7 +932,7 @@ class DateFormatService {
         let timeStringParts;
         let amFormat = this.labels.timeFormatAM;
         let pmFormat = this.labels.timeFormatPM;
-        if (!(timeString && timeString.includes(':'))) {
+        if (!(timeString?.includes(':'))) {
             return [value, timeString];
         }
         if (!militaryTime && amFormat && pmFormat) {
@@ -850,14 +948,14 @@ class DateFormatService {
                 splits = timeString.split(pmFormat);
                 pm = true;
             }
-            if (splits && splits.length) {
+            if (splits?.length) {
                 for (const item of splits) {
-                    if (item && item.trim().includes(':')) {
+                    if (item?.trim().includes(':')) {
                         timeStringParts = item.trim().split(':');
                     }
                 }
             }
-            if (timeStringParts && timeStringParts.length && timeStringParts.length === 2) {
+            if (timeStringParts?.length && timeStringParts.length === 2) {
                 let hours = parseInt(timeStringParts[0], 10);
                 if (hours === 12 && pm) {
                     hours = 12;
@@ -875,7 +973,7 @@ class DateFormatService {
         }
         else {
             timeStringParts = /(\d{1,2}):(\d{2})/.exec(timeString);
-            if (timeStringParts && timeStringParts.length && timeStringParts.length === 3) {
+            if (timeStringParts?.length && timeStringParts.length === 3) {
                 value.setHours(parseInt(timeStringParts[1], 10));
                 value.setMinutes(parseInt(timeStringParts[2], 10));
                 value.setSeconds(0);
@@ -884,6 +982,9 @@ class DateFormatService {
         return [value, timeString];
     }
     parseString(dateTimeString, militaryTime, type) {
+        if (!(dateTimeString?.length)) {
+            return null;
+        }
         switch (type) {
             case 'datetime':
                 const str = dateTimeString.replace(/-/g, '/');
@@ -902,18 +1003,23 @@ class DateFormatService {
                 return;
         }
     }
-    isValidDatePart(value, format) {
-        const datePart = parseInt(value, 10);
-        if (format.includes('m') && (datePart >= 2 || value.length === 2)) {
-            return true;
-        }
-        else if (format.includes('d') && (datePart >= 4 || value.length === 2)) {
-            return true;
+    convertTime12to24(time12h) {
+        const pmFormat = this.labels.timeFormatPM.toUpperCase();
+        const [time, modifier] = time12h.split(' ');
+        let [hours, minutes] = time.split(':');
+        if (hours === '12') {
+            hours = '00';
         }
-        else if (format.includes('y') && datePart >= 1000) {
-            return true;
+        if (['PM', pmFormat].includes(modifier)) {
+            hours = `${parseInt(hours, 10) + 12}`.padStart(2, '0');
         }
-        return false;
+        return `${hours}:${minutes}`;
+    }
+    isValidDatePart(value, format) {
+        const datePart = parseInt(value, 10);
+        return ((format.includes('m') && (datePart >= 2 || value.length === 2)) ||
+            (format.includes('d') && (datePart >= 4 || value.length === 2)) ||
+            (format.includes('y') && datePart >= 1000));
     }
 }
 DateFormatService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: DateFormatService, deps: [{ token: NovoLabelService }], target: i0.ɵɵFactoryTarget.Injectable });
@@ -928,6 +1034,9 @@ class BrowserGlobalRef extends GlobalRef {
     get nativeGlobal() {
         return window;
     }
+    get nativeWindow() {
+        return window;
+    }
 }
 BrowserGlobalRef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BrowserGlobalRef, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
 BrowserGlobalRef.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BrowserGlobalRef });
@@ -939,6 +1048,9 @@ class NodeGlobalRef extends GlobalRef {
         throw new Error(`global doesn't compile for some reason`);
         // return global as Global;
     }
+    get nativeWindow() {
+        throw new Error('Node does not have a window object');
+    }
 }
 
 // App