ish-ui 1.0.19 → 1.0.21

package/dist/utils/dates/formatString.js

@@ -0,0 +1,195 @@
+/*
+ * Copyright ish group pty ltd. All rights reserved. https://www.ish.com.au
+ * No copying or use of this code is allowed without permission in writing from ish.
+ */
+import { parse, addWeeks, addDays, subDays, addMonths, addYears, setHours, setMinutes } from 'date-fns';
+import { DD_MMM_YYYY, DD_MMM_YYYY_HH_MM, HH_MM_COLONED } from './format';
+const transitionDate = new Date(2000, 0, 1);
+const formatsWithLetters = [
+    'dMMMyy',
+    'dMMMMyy',
+    'ddMMMyy',
+    'ddMMMMyy',
+    'dMMMyyyy',
+    'dMMMMyyyy',
+    'ddMMMMyyyy',
+    'ddMMMyyyy'
+];
+const specialOptions = ['tm', 'yd', 'tomorrow', 'yesterday'];
+const operatorsRegexp = /\s*[-+]\s*[0-9][0-9]?[dDmMyYwW]?/g;
+const dividersRegexp = /[.\/\-]/g;
+const timeRegexp = /(\s|^)[0-9][0-9]?:[0-9][0-9]?/;
+const manageDatePart = (date, part) => {
+    const numberPart = parseInt(part, 10);
+    switch (true) {
+        case /[mM]/.test(part): {
+            return addMonths(date, numberPart);
+        }
+        case /[yY]/.test(part): {
+            return addYears(date, numberPart);
+        }
+        case /[wW]/.test(part): {
+            return addWeeks(date, numberPart);
+        }
+        case /[dD]/.test(part):
+        default: {
+            return addDays(date, numberPart);
+        }
+    }
+};
+const checkInvalidDate = (date) => date.toString() !== 'Invalid Date';
+export const formatStringDate = (dateString, type, baseDate, customFormat) => {
+    let result;
+    let parsed;
+    let formatted = dateString;
+    if (type === 'date') {
+        baseDate.setHours(0, 0, 0, 0);
+    }
+    if (customFormat) {
+        parsed = parse(dateString.replace(/^\w{3}/, '').trim(), customFormat, baseDate);
+        if (checkInvalidDate(parsed)) {
+            return parsed;
+        }
+        parsed = null;
+    }
+    if (type === 'date') {
+        parsed = parse(dateString.replace(/^\w{3}/, '').trim(), DD_MMM_YYYY, baseDate);
+        if (checkInvalidDate(parsed)) {
+            return parsed;
+        }
+        parsed = null;
+    }
+    if (type === 'datetime') {
+        parsed = parse(dateString.replace(/^\w{3}/, '').trim(), DD_MMM_YYYY_HH_MM, baseDate);
+        if (checkInvalidDate(parsed)) {
+            return parsed;
+        }
+        parsed = null;
+    }
+    if (type === 'time') {
+        parsed = parse(dateString, HH_MM_COLONED, baseDate);
+        if (checkInvalidDate(parsed)) {
+            return parsed;
+        }
+        parsed = parse(dateString, 'HH', baseDate);
+        if (checkInvalidDate(parsed)) {
+            return parsed;
+        }
+        parsed = null;
+    }
+    const dividers = dateString.match(dividersRegexp);
+    const operators = dateString.match(operatorsRegexp);
+    const time = dateString.match(timeRegexp);
+    if (time) {
+        formatted = formatted.replace(timeRegexp, '');
+    }
+    if (operators) {
+        formatted = formatted.replace(operatorsRegexp, '');
+    }
+    const hasLetters = formatted.match(/[a-zA-Z]/);
+    if (hasLetters) {
+        for (const format of formatsWithLetters) {
+            parsed = parse(formatted.replace(/\s/g, ''), format, baseDate);
+            if (checkInvalidDate(parsed)) {
+                result = parsed;
+                break;
+            }
+        }
+    }
+    if (dividers && !hasLetters) {
+        const dateParts = formatted.trim().split(dividersRegexp);
+        formatted = formatted.replace(dividersRegexp, ' ');
+        let formatString = `${dateParts[0] ? dateParts[0].replace(/./g, 'd') : ''} ${dateParts[1] ? dateParts[1].replace(/./g, 'M') : ''} ${dateParts[2] ? dateParts[2].replace(/./g, 'y') : ''}`;
+        if (dateParts[2] && dateParts[2].length === 1) {
+            formatted = formatted.replace(new RegExp(dateParts[2] + '$'), `0${dateParts[2]}`);
+            formatString = formatString.replace(new RegExp('y$'), 'yy');
+        }
+        parsed = parse(formatted, formatString.trim(), baseDate);
+        if (checkInvalidDate(parsed)) {
+            result = parsed;
+        }
+    }
+    if (!dividers && !hasLetters) {
+        switch (formatted.length) {
+            case 1:
+            case 2: {
+                parsed = parse(formatted, 'dd', baseDate);
+                if (checkInvalidDate(parsed)) {
+                    result = parsed;
+                }
+                break;
+            }
+            case 3: {
+                parsed = parse(formatted, 'ddM', baseDate);
+                if (checkInvalidDate(parsed)) {
+                    result = parsed;
+                }
+                break;
+            }
+            case 4: {
+                parsed = parse(`${formatted[0]} ${formatted[1]} ${formatted[2] + formatted[3]}`, 'd M yy', transitionDate);
+                if (checkInvalidDate(parsed)) {
+                    result = parsed;
+                }
+                break;
+            }
+            case 5: {
+                parsed = parse(formatted, 'ddMyy', transitionDate);
+                if (checkInvalidDate(parsed)) {
+                    result = parsed;
+                }
+                break;
+            }
+            case 6: {
+                parsed = parse(formatted, 'ddMMyy', transitionDate);
+                if (checkInvalidDate(parsed)) {
+                    result = parsed;
+                    break;
+                }
+                break;
+            }
+            case 8: {
+                parsed = parse(formatted, 'ddMMyyyy', transitionDate);
+                if (checkInvalidDate(parsed)) {
+                    result = parsed;
+                }
+            }
+        }
+    }
+    if (!(result instanceof Date)) {
+        result = baseDate;
+        for (const option of specialOptions) {
+            if (formatted === option) {
+                switch (option) {
+                    case 'tomorrow':
+                    case 'tm': {
+                        result = addDays(result, 1);
+                        break;
+                    }
+                    case 'yesterday':
+                    case 'yd': {
+                        result = subDays(result, 1);
+                    }
+                }
+                break;
+            }
+        }
+    }
+    if (operators) {
+        operators.forEach(op => {
+            result = manageDatePart(result, op.trim());
+        });
+    }
+    if (time && (type === 'time' || type === 'datetime')) {
+        parsed = parse(time[0].trim(), 'HH:mm', baseDate);
+        if (checkInvalidDate(parsed)) {
+            result = setHours(result, parsed.getHours());
+            result = setMinutes(result, parsed.getMinutes());
+        }
+    }
+    return result;
+};
+export const formatDurationMinutes = (minutes) => {
+    const duration = (minutes / 60).toString().split('.');
+    return `${duration[0] === '0' ? '' : duration[0] + 'h'} ${duration[1] ? (parseFloat('0.' + duration[1]) * 60).toFixed() + 'min' : ''}`.trim();
+};

package/dist/utils/dates/formatTimezone.d.ts

@@ -0,0 +1,2 @@
+export declare const appendTimezone: (date: Date, timezone: string) => Date;
+export declare const prependTimezone: (date: Date, timezone: string) => Date;

package/dist/utils/dates/formatTimezone.js

@@ -0,0 +1,35 @@
+/*
+ * Copyright ish group pty ltd 2020.
+ *
+ * This program is free software: you can redistribute it and/or modify it under the terms of the
+ * GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ */
+import { utcToZonedTime, zonedTimeToUtc } from 'date-fns-tz';
+export const appendTimezone = (date, timezone) => {
+    let result = date;
+    try {
+        result = utcToZonedTime(date, timezone);
+    }
+    catch (e) {
+        // eslint-disable-next-line no-console
+        console.warn(e);
+        return date;
+    }
+    return result;
+};
+export const prependTimezone = (date, timezone) => {
+    let result = date;
+    try {
+        result = zonedTimeToUtc(date, timezone);
+    }
+    catch (e) {
+        // eslint-disable-next-line no-console
+        console.warn(e);
+        return date;
+    }
+    return result;
+};

package/dist/utils/dates/index.d.ts

@@ -0,0 +1,6 @@
+export * from './datesNormalizing';
+export * from './format';
+export * from './formatRelative';
+export * from './formatString';
+export * from './formatTimezone';
+export * from './timetable';

package/dist/utils/dates/index.js

@@ -0,0 +1,13 @@
+/*
+ * Copyright ish group pty ltd 2023.
+ *
+ * This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
+ */
+export * from './datesNormalizing';
+export * from './format';
+export * from './formatRelative';
+export * from './formatString';
+export * from './formatTimezone';
+export * from './timetable';

package/dist/utils/dates/timetable.d.ts

@@ -0,0 +1,5 @@
+export declare const getCalendarDays: (today: any) => {
+    day: number;
+    date: Date;
+    status: any;
+}[];

package/dist/utils/dates/timetable.js

@@ -0,0 +1,38 @@
+/*
+ * Copyright ish group pty ltd 2023.
+ *
+ * This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
+ */
+import { getDay, getDaysInMonth, lastDayOfMonth } from 'date-fns';
+const generateOneMonth = (today, status) => Array(getDaysInMonth(today))
+    .fill(null)
+    .map((el, id) => ({
+    day: id + 1,
+    date: new Date(today.getFullYear(), today.getMonth(), id + 1),
+    status
+}));
+export const getCalendarDays = today => {
+    const currentMonth = generateOneMonth(today, 'current');
+    const previousMonth = generateOneMonth(new Date(today.getFullYear(), today.getMonth() - 1), 'previous');
+    const nextMonth = generateOneMonth(new Date(today.getFullYear(), today.getMonth() + 1), 'next');
+    const firstDayIndex = getDay(new Date(today.getFullYear(), today.getMonth(), 1));
+    const lastDayIndex = getDay(lastDayOfMonth(today));
+    const binaryCalendarState = (firstDayIndex, lastDayIndex) => parseInt(String(+!!firstDayIndex) + +(lastDayIndex < 6), 2);
+    switch (binaryCalendarState(firstDayIndex, lastDayIndex)) {
+        case 0:
+            return currentMonth;
+        case 1:
+            return currentMonth.concat(nextMonth.slice(0, 6 - lastDayIndex));
+        case 2:
+            return previousMonth.slice(previousMonth.length - firstDayIndex).concat(currentMonth);
+        case 3:
+            return previousMonth
+                .slice(previousMonth.length - firstDayIndex)
+                .concat(currentMonth)
+                .concat(nextMonth.slice(0, 6 - lastDayIndex));
+        default:
+            return currentMonth;
+    }
+};

package/dist/utils/events/index.d.ts

@@ -0,0 +1,2 @@
+export declare const stopEventPropagation: (e: any) => any;
+export declare const preventEventDefault: (e: any) => any;

package/dist/utils/events/index.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright ish group pty ltd. All rights reserved. https://www.ish.com.au
+ * No copying or use of this code is allowed without permission in writing from ish.
+ */
+export const stopEventPropagation = e => e.stopPropagation();
+export const preventEventDefault = e => e.preventDefault();

package/dist/utils/fields/index.d.ts

@@ -0,0 +1 @@
+export declare const getCheckboxValue: (value: any, stringValue: any) => boolean;

package/dist/utils/fields/index.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright ish group pty ltd 2023.
+ *
+ * This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
+ */
+export const getCheckboxValue = (value, stringValue) => {
+    if (!stringValue) {
+        return !!value;
+    }
+    switch (value) {
+        case 'false':
+            return false;
+        case 'true':
+            return true;
+        default:
+            return Boolean(value);
+    }
+};

package/dist/utils/formatting/PhoneMasks.d.ts

@@ -0,0 +1,304 @@
+export declare const phoneMasks: {
+    AC: string;
+    AD: string;
+    AE: string;
+    AE1: string;
+    AF: string;
+    AG: string;
+    AI: string;
+    AL: string;
+    AM: string;
+    AN: string;
+    AN1: string;
+    AN2: string;
+    AO: string;
+    AQ: string;
+    AR: string;
+    AS: string;
+    AT: string;
+    AU: string;
+    AU1: string;
+    AU2: string;
+    AU3: string;
+    AU4: string;
+    AU5: string;
+    AU6: string;
+    AW: string;
+    AZ: string;
+    BA: string;
+    BA1: string;
+    BB: string;
+    BD: string;
+    BE: string;
+    BF: string;
+    BG: string;
+    BH: string;
+    BI: string;
+    BJ: string;
+    BM: string;
+    BN: string;
+    BO: string;
+    BR: string;
+    BR1: string;
+    BR2: string;
+    BS: string;
+    BT: string;
+    BT1: string;
+    BW: string;
+    BY: string;
+    BZ: string;
+    CA: string;
+    CD: string;
+    CF: string;
+    CG: string;
+    CH: string;
+    CI: string;
+    CK: string;
+    CL: string;
+    CM: string;
+    CN: string;
+    CN1: string;
+    CN2: string;
+    CO: string;
+    CR: string;
+    CU: string;
+    CV: string;
+    CW: string;
+    CY: string;
+    CZ: string;
+    DE: string;
+    DE1: string;
+    DE2: string;
+    DE3: string;
+    DE4: string;
+    DE5: string;
+    DJ: string;
+    DK: string;
+    DM: string;
+    DO: string;
+    DO1: string;
+    DO2: string;
+    DZ: string;
+    EC: string;
+    EC1: string;
+    EE: string;
+    EE1: string;
+    EG: string;
+    ER: string;
+    ES: string;
+    ET: string;
+    FI: string;
+    FJ: string;
+    FK: string;
+    FM: string;
+    FO: string;
+    FR: string;
+    FR1: string;
+    FR2: string;
+    FR3: string;
+    GA: string;
+    GD: string;
+    GE: string;
+    GF: string;
+    GH: string;
+    GI: string;
+    GL: string;
+    GM: string;
+    GN: string;
+    GQ: string;
+    GR: string;
+    GT: string;
+    GU: string;
+    GW: string;
+    GY: string;
+    HK: string;
+    HN: string;
+    HR: string;
+    HT: string;
+    HU: string;
+    ID: string;
+    ID1: string;
+    ID2: string;
+    ID3: string;
+    ID4: string;
+    ID5: string;
+    IE: string;
+    IL: string;
+    IL1: string;
+    IN: string;
+    IO: string;
+    IQ: string;
+    IR: string;
+    IS: string;
+    IT: string;
+    JM: string;
+    JO: string;
+    JP: string;
+    JP1: string;
+    KE: string;
+    KG: string;
+    KH: string;
+    KI: string;
+    KM: string;
+    KN: string;
+    KP: string;
+    KP1: string;
+    KP2: string;
+    KP3: string;
+    KP4: string;
+    KP5: string;
+    KR: string;
+    KW: string;
+    KY: string;
+    KZ: string;
+    KZ1: string;
+    LA: string;
+    LA1: string;
+    LB: string;
+    LB1: string;
+    LC: string;
+    LI: string;
+    LK: string;
+    LR: string;
+    LS: string;
+    LT: string;
+    LU: string;
+    LV: string;
+    LY: string;
+    LY1: string;
+    MA: string;
+    MC: string;
+    MC1: string;
+    MD: string;
+    ME: string;
+    MG: string;
+    MH: string;
+    MK: string;
+    ML: string;
+    MM: string;
+    MM1: string;
+    MN: string;
+    MO: string;
+    MP: string;
+    MQ: string;
+    MR: string;
+    MS: string;
+    MT: string;
+    MU: string;
+    MV: string;
+    MW: string;
+    MW1: string;
+    MX: string;
+    MX1: string;
+    MY: string;
+    MY1: string;
+    MY2: string;
+    MY3: string;
+    MZ: string;
+    NA: string;
+    NC: string;
+    NE: string;
+    NF: string;
+    NG: string;
+    NG1: string;
+    NG2: string;
+    NG3: string;
+    NI: string;
+    NL: string;
+    NO: string;
+    NP: string;
+    NR: string;
+    NU: string;
+    NZ: string;
+    NZ1: string;
+    NZ2: string;
+    OM: string;
+    PA: string;
+    PE: string;
+    PF: string;
+    PG: string;
+    PH: string;
+    PK: string;
+    PL: string;
+    PS: string;
+    PT: string;
+    PW: string;
+    PY: string;
+    QA: string;
+    RE: string;
+    RO: string;
+    RS: string;
+    RU: string;
+    RW: string;
+    SA: string;
+    SA1: string;
+    SB: string;
+    SB1: string;
+    SC: string;
+    SD: string;
+    SE: string;
+    SG: string;
+    SH: string;
+    SH1: string;
+    SI: string;
+    SK: string;
+    SL: string;
+    SM: string;
+    SN: string;
+    SO: string;
+    SO1: string;
+    SO2: string;
+    SR: string;
+    SR1: string;
+    SS: string;
+    ST: string;
+    SV: string;
+    SX: string;
+    SY: string;
+    SZ: string;
+    TC: string;
+    TD: string;
+    TG: string;
+    TH: string;
+    TH1: string;
+    TJ: string;
+    TK: string;
+    TL: string;
+    TL1: string;
+    TL2: string;
+    TM: string;
+    TN: string;
+    TO: string;
+    TR: string;
+    TT: string;
+    TV: string;
+    TV1: string;
+    TW: string;
+    TW1: string;
+    TZ: string;
+    UA: string;
+    UG: string;
+    UK: string;
+    US: string;
+    UY: string;
+    UZ: string;
+    VA: string;
+    VC: string;
+    VE: string;
+    VG: string;
+    VI: string;
+    VN: string;
+    VN1: string;
+    VU: string;
+    VU1: string;
+    WF: string;
+    WS: string;
+    YE: string;
+    YE1: string;
+    YE2: string;
+    ZA: string;
+    ZM: string;
+    ZW: string;
+    DEFAULT: string;
+};
+export declare const getPhoneMask: (value: string) => any;