diginet-core-ui 1.4.39 → 1.4.40

package/src/utils/date.js

@@ -0,0 +1,391 @@
+import { getGlobal } from '../global';
+import locale from '../locale';
+
+const language = locale.get();
+const localeName = language === 'en' ? 'en-US' : 'vi-VN';
+const units = ['year', 'month', 'day', 'hour', 'minute', 'second', 'millisecond'];
+
+/**
+ *
+ * @param {Date|String|Array} value is a date time
+ * @param {String} format the input date format
+ * @param {Boolean} setNow return current time if true
+ */
+const getDate = (value, format = 'MM/DD/YYYY', setNow = true) => {
+    if (value) {
+        if (Array.isArray(value)) {
+            value = value.join('/');
+        }
+        if (typeof value === 'string') {
+            if (format.replace(/\W/g, '/') === 'DD/MM/YYYY') {
+                value = value.replace(/^(\d{1,2}\/)(\d{1,2}\/)/, '$2$1');
+            }
+        }
+        return new Date(value);
+    } else if (setNow) {
+        return new Date();
+    }
+};
+const getMethodOfUnit = unit => {
+    switch (unit.toLowerCase()) {
+        case 'years':
+        case 'year':
+            return 'FullYear';
+        case 'months':
+        case 'month':
+            return 'Month';
+        case 'days':
+        case 'day':
+            return 'Date';
+        case 'hours':
+        case 'hour':
+            return 'Hours';
+        case 'minutes':
+        case 'minute':
+            return 'Minutes';
+        case 'seconds':
+        case 'second':
+            return 'Seconds';
+        case 'millisecond':
+            return 'Milliseconds';
+        default:
+            return 'Date';
+    }
+};
+
+/**
+ * check 1 value is a date
+ * @param {Date|String|Array|Number} value the value to check
+ * @param {String} formatInput the format date to check valid date
+ * @returns {Boolean} valid date
+ */
+export const isValidDate = (value, formatInput) => {
+    if (typeof value === 'string' || Array.isArray(value)) {
+        if (String(getDate(value, formatInput)) !== 'Invalid Date') {
+            return true;
+        }
+    } else if (Object.prototype.toString.call(value) === '[object Date]' && String(value) !== 'Invalid Date') {
+        return true;
+    }
+    return false;
+};
+
+/**
+ * get the end of month from month and year or from a date
+ * @param {Number|String|Date|Array} month the month of year (can also be validated as year) or a value with date type
+ * @param {Number} year the year (can also be validated as month if arg 1 is year)
+ * @returns {Number} end day
+ */
+export const getEndDayOfMonth = (month, year) => {
+    if (!year) {
+        if (/number|string/.test(typeof month) || Array.isArray(month)) {
+            month = getDate(getDate, undefined, false);
+            if (String(month) !== 'Invalid Date') {
+                return new Date(month.getFullYear(), month.getMonth(), 0).getDate();
+            }
+        } else if (isValidDate(month)) {
+            return new Date(month.getFullYear(), month.getMonth(), 0).getDate();
+        }
+    } else if (!isNaN(month) && !isNaN(year)) {
+        return new Date(year > 12 ? year : year - 1, month > 12 ? month : month - 1, 0)?.getDate?.();
+    }
+    return 'Invalid Date';
+};
+
+/**
+ * return a date time follow the concrete format
+ * @param {Date|String|Array} value is a date time
+ * @param {String} formatOutput format of date
+ * @param {Boolean} utc is utc time
+ */
+export const formatDate = (value, formatOutput = 'DD/MM/YYYY', utc = false) => {
+    if (!value) return formatOutput;
+    formatOutput = formatOutput.trim();
+    if (typeof value === 'string') {
+        value = new Date(value);
+        if (String(value) === 'Invalid Date') {
+            return 'Invalid Date';
+        }
+    }
+
+    const dateTime = (() => {
+        const UTC = utc ? 'UTC' : '';
+        const year = value['get' + UTC + 'FullYear']();
+        const month = value['get' + UTC + 'Month']();
+        const day = value['get' + UTC + 'Day']();
+        const dayOfYear = Math.ceil(value.valueOf() - new Date(year).valueOf() / 86400000);
+        const hours = value['get' + UTC + 'Hours']();
+        const timeZone = value
+            .toTimeString()
+            .match(/\+[0-9]{4}/)?.[0]
+            .replace(/\+(\d{2})/, '+$1:');
+        return {
+            // Date - Month - Year
+            YY: year.toString().slice(-2), // 21
+            YYYY: year, // 2021
+            M: month + 1, // 1
+            MM: ('0' + (month + 1).toString()).slice(-2), // 01
+            MMM: getGlobal(['months', 'notFull', month]), // Jan
+            MMMM: getGlobal(['months', 'full', month]), // January
+            D: value['get' + UTC + 'Date'](), // 26
+            DD: ('0' + value['get' + UTC + 'Date']().toString()).slice(-2), // 26
+            DDD: dayOfYear, // 26 - day of year
+            DDDD: dayOfYear.toString().replace(/^(\d)$/, '0$1'), // 26 - 2 digit
+            dddd: getGlobal(['days', 'full', day]),
+            ddd: getGlobal(['days', 'notFull', day]),
+            e: day, // 2 - day of week
+            E: day + 1, // 3
+            Q: `Q${Math.ceil((month + 1) / 3)}`, // 1
+
+            // Hour + Minute + second
+            H: hours,
+            HH: ('0' + hours.toString()).slice(-2),
+            h: hours > 12 ? hours % 12 : hours,
+            hh: ('0' + hours > 12 ? hours % 12 : hours).toString().slice(-2),
+            K: hours + 1,
+            KK: ('0' + (hours + 1).toString()).slice(-2),
+            m: value['get' + UTC + 'Minutes'](),
+            mm: ('0' + value['get' + UTC + 'Minutes']().toString()).slice(-2),
+            s: value['get' + UTC + 'Seconds'](),
+            ss: ('0' + value['get' + UTC + 'Seconds']().toString()).slice(-2),
+            a: hours > 11 ? 'PM' : 'AM',
+            A: hours > 11 ? 'PM' : 'AM',
+            x: value.valueOf().toString(),
+            X: (value.valueOf() / 1000).toString(),
+            Z: timeZone,
+            ZZ: timeZone,
+        };
+    })();
+
+    const dateTimeFormat = (options = {}) => {
+        return new Intl.DateTimeFormat(localeName, options).format(value);
+    };
+
+    const getFullTime = unit => {
+        const fullDate = value.toLocaleDateString(localeName); // "1/26/2020"
+        const lll = dateTimeFormat({ dateStyle: 'medium', timeStyle: 'short' });
+        switch (unit) {
+            case 'L':
+                return fullDate
+                    .split('/')
+                    .map(v => (v.length > 1 ? v : '0' + v))
+                    .join('/');
+            case 'l':
+                return fullDate;
+            case 'LL':
+                return dateTimeFormat({ dateStyle: 'long' });
+            case 'll':
+                return dateTimeFormat({ dateStyle: 'medium' });
+            case 'LLL':
+                return dateTimeFormat({ dateStyle: 'long', timeStyle: 'short' });
+            case 'lll':
+                return lll;
+            case 'LLLL':
+                return dateTimeFormat({ dateStyle: 'full', timeStyle: 'short' });
+            case 'llll':
+                return dateTime.ddd + ', ' + lll;
+            case 'LT':
+                return dateTimeFormat({ date: 'none', timeStyle: 'short' });
+            case 'LTS':
+                return dateTimeFormat({ date: 'none', timeStyle: 'medium' });
+            default:
+                return 'Invalid format';
+        }
+    };
+
+    const getUnitFormat = unit => {
+        if (/l/i.test(unit)) {
+            return getFullTime(unit);
+        }
+        {
+            return dateTime[unit];
+        }
+    };
+
+    const arrFormat = formatOutput.split(/\W+/g);
+    if (arrFormat.length) {
+        arrFormat.forEach(unit => {
+            formatOutput = formatOutput.replace(unit, getUnitFormat(unit));
+        });
+        return formatOutput;
+    }
+};
+
+/**
+ * return a date like moment
+ * @param {Date|String|Array} value is date time
+ * @param {String} formatInput format of input date value
+ * @returns {Object} date
+ */
+const date = (value, formatInput = 'MM/DD/YYYY') => {
+    const originDate = getDate(value, formatInput);
+
+    /**
+     * compare two date time and return a period
+     * @param {Date|String|Array} date is a date time
+     * @param {String} unit one of milliseconds|seconds|minutes|hours|days|months|years
+     * @param {Boolean|Number} floating allow odd numbers
+     * @returns {Number} distance
+     */
+    const diff = (compareDate, unit = 'days', floating = false) => {
+        compareDate = getDate(compareDate);
+        if (String(compareDate) === 'Invalid Date' || !isValidDate(originDate, formatInput)) {
+            return 'Invalid Date';
+        }
+        let result = [];
+        if (/months|years/.test(unit.toLowerCase())) {
+            const originDateArr = formatDate(originDate, 'YYYY/MM/DD HH:mm:ss').split(/\W+/);
+            const compareDateArr = formatDate(compareDate, 'YYYY/MM/DD HH:mm:ss').split(/\W+/);
+            const endDayOfMonth = getEndDayOfMonth(originDate);
+            const similarMaxTimeArr = [1, 12, endDayOfMonth, 24, 60, 60, 1000];
+            let decimalTotal = 0,
+                currentValueOfUnit = 1;
+
+            for (let i = originDateArr.length - 1; i >= 0; i--) {
+                result[i] = originDateArr[i] - compareDateArr[i];
+                if (i > 1) {
+                    currentValueOfUnit *= similarMaxTimeArr[i + 1];
+                    decimalTotal += result[i] * currentValueOfUnit;
+                }
+            }
+            const decimalOfMonth = decimalTotal / (endDayOfMonth * 86400000);
+            result = result[0] * 12 + result[1] + decimalOfMonth;
+            if (unit.toLowerCase() === 'years') {
+                result = Math.ceil(result / 12);
+            }
+        } else {
+            const getValueOfUnit = (week = 1) => {
+                switch (unit.toLowerCase()) {
+                    case 'days':
+                        return 86400000;
+                    case 'hours':
+                        return 3600000;
+                    case 'minutes':
+                        return 60000;
+                    case 'seconds':
+                        return 1000;
+                    case 'milliseconds':
+                        return 1;
+                    default:
+                        return 86400000 * week;
+                }
+            };
+            result = (originDate.valueOf() - compareDate.valueOf()) / getValueOfUnit(unit === 'weeks' ? 1 : 7);
+        }
+        return result.toFixed(floating ? (typeof floating === 'number' ? floating : 2) : 0);
+    };
+
+    /**
+     * add or subtract date time
+     * @param {Number} num the quantity to cal for unit
+     * @param {String} unit the unit of date/time
+     * @param {String} operator operator to cal (add/subtract)
+     * @returns {Object} date
+     */
+    const calculation = (num, unit, operator) => {
+        if (isNaN(num)) {
+            return NaN;
+        }
+        // Example: unit === 'days' -> originDate.setDate(originDate.getDate() +/- num)
+        originDate['set' + getMethodOfUnit(unit)](
+            originDate['get' + getMethodOfUnit(unit)]() + (operator === 'add' ? +num : -num)
+        );
+        return date(originDate, formatInput);
+    };
+
+    /**
+     * get the moment of time follow unit time
+     * @param {String} unit the unit of time
+     * @param {String} moment start|end to get start|end of the moment
+     * @returns {Object} date
+     */
+    const timeOf = (unit, moment) => {
+        let temp = 1;
+        if (!units.includes(unit)) {
+            unit = 'day';
+        }
+        units.forEach(u => {
+            const method = getMethodOfUnit(u);
+            const valueUnitTime = originDate['get' + method]();
+            if (u === unit) {
+                const addTime = moment === 'start' ? 0 : 1;
+                originDate['set' + method](valueUnitTime + addTime);
+                temp = 0;
+            } else {
+                const time =
+                    u === 'millisecond'
+                        ? moment === 'start'
+                            ? 0
+                            : -1
+                        : u === 'day'
+                        ? Math.max(1, valueUnitTime * temp)
+                        : valueUnitTime * temp;
+
+                originDate['set' + method](time);
+            }
+        });
+        return date(originDate, formatInput);
+    };
+
+    /**
+     *
+     * @param {Date|String|Number|Array} compareDate date to calculate moment, undefined will compare with now
+     * @param {String|Array} unit year|month|day|hour|minute|second|millisecond, allow undefined
+     * @param {Boolean|Number} floating allow odd numbers
+     * @returns {String} moments
+     */
+    const relative = (compareDate, unit, floating) => {
+        compareDate = getDate(compareDate);
+        if (String(compareDate) === 'Invalid Date' || !isValidDate(originDate, formatInput)) {
+            return 'Invalid Date';
+        }
+        if (typeof unit === 'string' && /s$/.test(unit)) {
+            unit = unit.replace(/s$/, '');
+        }
+        if (!unit || (typeof unit === 'string' && !units.includes(unit))) {
+            unit = units;
+        }
+        let num;
+        if (Array.isArray(unit)) {
+            for (let i = 0; i < unit.length; i++) {
+                num = diff(compareDate, unit[i] + 's', floating ? (typeof floating === 'number' ? floating : 2) : 1);
+                if (Math.abs(num) >= 1) {
+                    unit = unit[i];
+                    break;
+                }
+            }
+        } else {
+            num = diff(compareDate, unit + 's', floating ? (typeof floating === 'number' ? floating : 2) : 1);
+        }
+        num = (+num).toFixed(floating ? (typeof floating === 'number' ? floating : 2) : 0);
+        try {
+            return new Intl.RelativeTimeFormat(language, { numeric: 'auto' }).format(-num, unit);
+        } catch (e) {
+            return e.message;
+        }
+    };
+
+    return {
+        value: originDate,
+        /**
+         * return a date time follow the concrete format
+         * @param {String} formatOutput format of date
+         * @param {Boolean} utc is utc time
+         */
+        format: (formatOutput, utc) => formatDate(originDate, formatOutput, utc),
+        diff,
+        /**
+         * check 1 value is a date
+         * @param {String} formatInput the format date to check valid date
+         * @returns {Boolean} valid date
+         */
+        isValid: () => isValidDate(originDate, formatInput),
+        add: (num, unit) => calculation(num, unit, 'add'),
+        subtract: (num, unit) => calculation(num, unit, 'subtract'),
+        startOf: unit => timeOf(unit, 'start'),
+        endOf: unit => timeOf(unit, 'end'),
+        relative,
+    };
+};
+
+export default date;

package/src/utils/error/error.js

@@ -0,0 +1,65 @@
+import { extend } from '../object/extend';
+import { logger } from '../console';
+import { format } from '../string/string';
+
+/**
+ * future
+ */
+const ERROR_URL = 'http://core.diginet.com.vn/ui/error/';
+
+export default function (baseErrors, errors) {
+    const exports = {
+        ERROR_MESSAGES: extend(errors, baseErrors),
+
+        Error: function () {
+            return makeError([].slice.call(arguments));
+        },
+
+        log: function (id) {
+            let method = 'log';
+
+            if (/^E\d+$/.test(id)) {
+                method = 'error';
+            } else if (/^W\d+$/.test(id)) {
+                method = 'warn';
+            }
+
+            logger[method](method === 'log' ? id : combineMessage([].slice.call(arguments)));
+        },
+    };
+
+    function combineMessage(args) {
+        const id = args[0];
+        args = args.slice(1);
+        return formatMessage(id, formatDetails(id, args));
+    }
+
+    function formatDetails(id, args) {
+        args = [exports.ERROR_MESSAGES[id]].concat(args);
+        return format.apply(this, args).replace(/\.*\s*?$/, '');
+    }
+
+    function formatMessage(id, details) {
+        return format.apply(this, ['{0} - {1}. See:\n{2}', id, details, getErrorUrl(id)]);
+    }
+
+    function makeError(args) {
+        const id = args[0];
+        args = args.slice(1);
+        const details = formatDetails(id, args);
+        const url = getErrorUrl(id);
+        const message = formatMessage(id, details);
+
+        return extend(new Error(message), {
+            __id: id,
+            __details: details,
+            url: url,
+        });
+    }
+
+    function getErrorUrl(id) {
+        return ERROR_URL + id;
+    }
+
+    return exports;
+}

package/src/utils/error/errors.js

@@ -0,0 +1,250 @@
+import errorUtils from './error';
+
+/**
+* @docid
+* @name ErrorsCore
+*/
+export default errorUtils({
+
+    /**
+    * @name ErrorsCore.E0001
+    */
+    E0001: 'Method is not implemented',
+
+    /**
+    * @name ErrorsCore.E0002
+    */
+    E0002: 'Member name collision: {0}',
+
+    /**
+    * @name ErrorsCore.E0003
+    */
+    E0003: 'A class must be instantiated using the \'new\' keyword',
+
+    /**
+    * @name ErrorsCore.E0004
+    */
+    E0004: 'The NAME property of the component is not specified',
+
+    /**
+    * @name ErrorsCore.E0005
+    */
+    E0005: 'Unknown device',
+
+    /**
+    * @name ErrorsCore.E0006
+    */
+    E0006: 'Unknown endpoint key is requested',
+
+    /**
+    * @name ErrorsCore.E0007
+    */
+    E0007: '\'Invalidate\' method is called outside the update transaction',
+
+    /**
+    * @name ErrorsCore.E0008
+    */
+    E0008: 'Type of the option name is not appropriate to create an action',
+
+    /**
+    * @name ErrorsCore.E0009
+    */
+    E0009: 'Component \'{0}\' has not been initialized for an element',
+
+    /**
+    * @name ErrorsCore.E0010
+    */
+    E0010: 'Animation configuration with the \'{0}\' type requires \'{1}\' configuration as {2}',
+
+    /**
+    * @name ErrorsCore.E0011
+    */
+    E0011: 'Unknown animation type \'{0}\'',
+
+    /**
+    * @name ErrorsCore.E0012
+    */
+    E0012: 'jQuery version is too old. Please upgrade jQuery to 1.10.0 or later',
+
+    /**
+    * @name ErrorsCore.E0013
+    */
+    E0013: 'KnockoutJS version is too old. Please upgrade KnockoutJS to 2.3.0 or later',
+
+    /**
+    * @name ErrorsCore.E0014
+    */
+    E0014: 'The \'release\' method shouldn\'t be called for an unlocked Lock object',
+
+    /**
+    * @name ErrorsCore.E0015
+    */
+    E0015: 'Queued task returned an unexpected result',
+
+    /**
+    * @name ErrorsCore.E0017
+    */
+    E0017: 'Event namespace is not defined',
+
+    /**
+    * @name ErrorsCore.E0018
+    */
+    E0018: 'DGN-UI-Popup widget is required',
+
+    /**
+    * @name ErrorsCore.E0020
+    */
+    E0020: 'Template engine \'{0}\' is not supported',
+
+    /**
+    * @name ErrorsCore.E0021
+    */
+    E0021: 'Unknown theme is set: {0}',
+
+    /**
+    * @name ErrorsCore.E0022
+    */
+    E0022: 'LINK[rel=DGN-UI-theme] tags must go before DGN-UI included scripts',
+
+    /**
+    * @name ErrorsCore.E0023
+    */
+    E0023: 'Template name is not specified',
+
+    /**
+    * @name ErrorsCore.E0024
+    */
+    E0024: 'DGN-UI bundle already included',
+
+    /**
+    * @name ErrorsCore.E0025
+    */
+    E0025: 'Unexpected argument type',
+
+    /**
+    * @name ErrorsCore.E0100
+    */
+    E0100: 'Unknown validation type is detected',
+
+    /**
+    * @name ErrorsCore.E0101
+    */
+    E0101: 'Misconfigured range validation rule is detected',
+
+
+    /**
+    * @name ErrorsCore.E0102
+    */
+    E0102: 'Misconfigured comparison validation rule is detected',
+
+    /**
+    * @name ErrorsCore.E0103
+    */
+    E0103: 'validationCallback of an asynchronous rule should return a jQuery or a native promise',
+
+    /**
+    * @name ErrorsCore.E0110
+    */
+    E0110: 'Unknown validation group is detected',
+
+    /**
+    * @name ErrorsCore.E0120
+    */
+    E0120: 'Adapter for a DGN-UI-Validator component cannot be configured',
+
+    /**
+    * @name ErrorsCore.E0121
+    */
+    E0121: 'The \'customItem\' field of the \'onCustomItemCreating\' function\'s parameter should contain a custom item or Promise that is resolved after the item is created.',
+
+
+    /**
+    * @name ErrorsCore.W0000
+    */
+    W0000: '\'{0}\' is deprecated in {1}. {2}',
+
+    /**
+    * @name ErrorsCore.W0001
+    */
+    W0001: '{0} - \'{1}\' option is deprecated in {2}. {3}',
+
+    /**
+    * @name ErrorsCore.W0002
+    */
+    W0002: '{0} - \'{1}\' method is deprecated in {2}. {3}',
+
+    /**
+    * @name ErrorsCore.W0003
+    */
+    W0003: '{0} - \'{1}\' property is deprecated in {2}. {3}',
+
+    /**
+    * @name ErrorsCore.W0004
+    */
+    W0004: 'Timeout for theme loading is over: {0}',
+
+    /**
+    * @name ErrorsCore.W0005
+    */
+    W0005: '\'{0}\' event is deprecated in {1}. {2}',
+
+    /**
+    * @name ErrorsCore.W0006
+    */
+    W0006: 'Invalid recurrence rule: \'{0}\'',
+
+    /**
+    * @name ErrorsCore.W0007
+    */
+    W0007: '\'{0}\' Globalize culture is not defined',
+
+    /**
+    * @name ErrorsCore.W0008
+    */
+    W0008: 'Invalid view name: \'{0}\'',
+
+    /**
+    * @name ErrorsCore.W0009
+    */
+    W0009: 'Invalid time zone name: \'{0}\'',
+
+    /**
+    * @name ErrorsCore.W0010
+    */
+    W0010: '{0} is deprecated in {1}. {2}',
+
+    /**
+    * @name ErrorsCore.W0011
+    */
+    W0011: 'Number parsing is invoked while the parser is not defined',
+
+    /**
+    * @name ErrorsCore.W0012
+    */
+    W0012: 'Date parsing is invoked while the parser is not defined',
+
+    /**
+    * @name ErrorsCore.W0013
+    */
+    W0013: '\'{0}\' file is deprecated in {1}. {2}',
+
+    /**
+    * @name ErrorsCore.W0014
+    */
+    W0014: '{0} - \'{1}\' type is deprecated in {2}. {3}',
+
+    /**
+    * @name ErrorsCore.W0015
+    */
+    W0015: 'Instead of returning a value from the \'{0}\' function, write it into the \'{1}\' field of the function\'s parameter.',
+
+    /**
+    * @name ErrorsCore.W0016
+    */
+    W0016: 'The "{0}" option does not accept the "{1}" value since v.{2}. {3}.',
+
+    /**
+    * @name ErrorsCore.W0017
+    */
+    W0017: 'Filter query string exceeds maximum length limit of {0} characters.'
+});