funda-ui 4.7.620 → 4.7.624

package/publish/lib/esm/Utils/libs/math.ts

@@ -0,0 +1,276 @@
+
+
+/**
+ * Evaluating a string as a mathematical expression
+ * @param {String} s      - An input string
+ * @returns {Number}   - New calculation result.
+ */
+function evaluate(s: string) {
+    const chars: string[] = s.replace(/\s/g, '').split("");
+    let n: string[] = [],
+        op: string[] = [], 
+        index: number = 0, 
+        oplast: boolean = true;
+
+    n[index] = "";
+
+    // Parse the expression
+    for (let c = 0; c < chars.length; c++) {
+
+        if (isNaN(parseInt(chars[c])) && chars[c] !== "." && !oplast) {
+            op[index] = chars[c];
+            index++;
+            n[index] = "";
+            oplast = true;
+        } else {
+            n[index] += chars[c];
+            oplast = false;
+        }
+    }
+
+    // Calculate the expression
+    let resStr: number = parseFloat(n[0]);
+    for (let o = 0; o < op.length; o++) {
+        const num = parseFloat(n[o + 1]);
+        switch (op[o]) {
+            case "+":
+                resStr = resStr + num;
+                break;
+            case "-":
+                resStr = resStr - num;
+                break;
+            case "*":
+                resStr = resStr * num;
+                break;
+            case "/":
+                resStr = resStr / num;
+                break;
+        }
+    }
+
+    return resStr;
+}
+
+
+/**
+ * Addition
+ * @param {Number} num1
+ * @param {Number} num2
+ * @return {Number} 
+ */
+function calcAdd(num1: number, num2: number) {
+    let baseNum, baseNum1, baseNum2;
+    try {
+        baseNum1 = num1.toString().split(".")[1].length;
+    } catch (e) {
+        baseNum1 = 0;
+    }
+    try {
+        baseNum2 = num2.toString().split(".")[1].length;
+    } catch (e) {
+        baseNum2 = 0;
+    }
+    baseNum = Math.pow(10, Math.max(baseNum1, baseNum2));
+    return (num1 * baseNum + num2 * baseNum) / baseNum;
+}
+
+/**
+ * Subtraction
+ * @param {Number} num1
+ * @param {Number} num2
+ * @return {Number} 
+ */
+function calcSub(num1: number, num2: number) {
+    let baseNum, baseNum1, baseNum2;
+    let precision;
+    try {
+        baseNum1 = num1.toString().split(".")[1].length;
+    } catch (e) {
+        baseNum1 = 0;
+    }
+    try {
+        baseNum2 = num2.toString().split(".")[1].length;
+    } catch (e) {
+        baseNum2 = 0;
+    }
+    baseNum = Math.pow(10, Math.max(baseNum1, baseNum2));
+    precision = (baseNum1 >= baseNum2) ? baseNum1 : baseNum2;
+    return ((num1 * baseNum - num2 * baseNum) / baseNum).toFixed(precision);
+}
+
+/**
+ * Multiplication
+ * @param {Number} num1
+ * @param {Number} num2
+ * @return {Number} 
+ */
+function calcMul(num1: number, num2: number) {
+    let baseNum = 0;
+    try {
+        baseNum += num1.toString().split(".")[1].length;
+    } catch (e) {
+    }
+    try {
+        baseNum += num2.toString().split(".")[1].length;
+    } catch (e) {
+    }
+    return Number(num1.toString().replace(".", "")) * Number(num2.toString().replace(".", "")) / Math.pow(10, baseNum);
+};
+/**
+ * Division
+ * @param {Number} num1
+ * @param {Number} num2
+ * @return {Number} 
+ */
+function calcDiv(num1: number, num2: number) {
+    let baseNum1 = 0, baseNum2 = 0;
+    let baseNum3, baseNum4;
+    try {
+        baseNum1 = num1.toString().split(".")[1].length;
+    } catch (e) {
+        baseNum1 = 0;
+    }
+    try {
+        baseNum2 = num2.toString().split(".")[1].length;
+    } catch (e) {
+        baseNum2 = 0;
+    }
+    baseNum3 = Number(num1.toString().replace(".", ""));
+    baseNum4 = Number(num2.toString().replace(".", ""));
+    return (baseNum3 / baseNum4) * (Math.pow(10, baseNum2 - baseNum1));
+}
+
+
+/**
+ * Determine if it's a number
+ * @param {*} n
+ * @returns {Boolean}
+ */
+function isNumeric(s: any) {
+    return !isNaN(parseFloat(s)) && isFinite(s);
+}
+
+
+/**
+ * Determine if it's a decimal
+ * @param {Number} num
+ * @returns {Boolean}
+ */
+function isDecimal(num: number) {
+    return num!== Math.floor(num);
+}
+
+
+/**
+ * Truncate Decimals
+ * @param {Number} num 
+ * @param {Number} decimalPlaces 
+ * @returns {Number}
+ */
+function truncateDecimals(num: number, decimalPlaces: number) {
+    const factor = Math.pow(10, decimalPlaces);
+    return Math.floor(num * factor) / factor;
+}
+
+
+/**
+ * Zero Pad
+ * @param {Number|String} n
+ * @param {?Number} decimalPlaces 
+ * @returns {String}
+ */
+function numZeroPad(n: number | string, decimalPlaces: number = 0) {
+    return parseFloat(String(n)).toFixed(decimalPlaces);
+}
+
+
+
+/**
+ * Check whether the number of decimal places exceeds the specified value
+ * @param {Number|String} s
+ * @param {Number} decimalPlaces 
+ * @returns {Boolean}
+ */
+function exceedDecimalPlaces(s: string | number, decimalPlaces: number) {
+    const parts = String(s).split(".");
+    return parts[1] && parts[1].length > decimalPlaces;
+}
+
+
+/**
+ * Format number
+ * @param {*} inputValue 
+ * @param {?Number} decimalPlaces 
+ * @param {Number|undefined} inputMin 
+ * @param {Number|undefined} inputMax 
+ * @returns {String}
+ */
+function formatNumber(inputValue: any, decimalPlaces: number = 0, inputMin: number | undefined = undefined, inputMax: number | undefined = undefined) {
+       
+    // STEP 1
+    // =================================================================
+    // Determine whether the value is legitimate
+    if (inputValue === '' || !isNumeric(inputValue)) {
+        return '';
+    }
+   
+    // STEP 2
+    // =================================================================
+    // check min or max value
+    if (
+        typeof inputMin !== 'undefined' && 
+        typeof inputMax !== 'undefined' && 
+        isNumeric(inputMin) && 
+        isNumeric(inputMax)
+    ) {
+        inputValue = Math.min(Number(inputValue), inputMax);
+        inputValue = Math.max(Number(inputValue), inputMin);
+    }
+
+   
+    // STEP 3
+    // =================================================================
+    // Remove characters that are not numbers and decimal points
+    let formattedValue = String(inputValue).replace(/[^0-9.\-]/g, "");
+
+           
+    // STEP 4
+    // =================================================================
+    // Prevent multiple decimal points
+    const parts = formattedValue.split(".");
+    if (parts.length > 2) {
+        formattedValue = `${parts[0]}.${parts[1]}`;
+    }
+
+           
+    // STEP 5
+    // =================================================================
+    // Limit the number of decimal places
+    if (parts[1] && parts[1].length > decimalPlaces) {
+        formattedValue = parseFloat(formattedValue).toFixed(decimalPlaces);
+    }
+
+
+    // STEP 6
+    // =================================================================
+    // Remove invalid zeros
+    formattedValue = Number(formattedValue).toPrecision();
+    
+
+    return formattedValue;
+}
+
+
+export {
+    evaluate,
+    calcAdd,
+    calcSub,
+    calcMul,
+    calcDiv,
+    isNumeric,
+    isDecimal,
+    truncateDecimals,
+    numZeroPad,
+    exceedDecimalPlaces,
+    formatNumber
+}

package/publish/lib/esm/Utils/libs/object.ts

@@ -0,0 +1,68 @@
+
+/**
+ * Remove Duplicate objects from JSON Array
+ * @param {Array} obj 
+ * @param {String} fieldName 
+ */
+function removeArrDuplicateItems(obj: any[], fieldName: string): any[] {
+    if (!Array.isArray(obj)) return [];
+
+    const clean = obj.filter((item, index, self) => index === self.findIndex((t) => (t[fieldName] === item[fieldName])));
+    return clean;
+};
+
+
+/**
+ * Deep clone
+ * @param {*} obj 
+ */
+function deepClone(obj: any): any {
+    if (Array.isArray(obj)) {
+        return (obj).map((item) => deepClone(item));
+    } else if (typeof obj === 'object' && obj !== null) {
+        const clone: any = {};
+        for (let key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                clone[key] = deepClone(obj[key]);
+            }
+        }
+        return clone;
+    } else {
+        return obj;
+    }
+}
+
+
+/**
+ * Flat Data
+ * @param {*} data 
+ * @returns 
+ */
+function flatData(data: any): any[] {
+    const result: any[] = [];
+    const iterate = (obj: any) => {
+        if (!obj) {
+            return;
+        }
+        obj.forEach((item: any) => {
+            result.push(item);
+            if (item.children) {
+                iterate(item.children);
+            }
+
+            // delete current item children
+            delete item.children;
+
+        })
+    }
+
+    iterate(data);
+    return result;
+}
+
+
+export {
+    removeArrDuplicateItems,
+    deepClone,
+    flatData
+}

package/publish/lib/esm/Utils/libs/os.ts

@@ -0,0 +1,63 @@
+
+
+/*
+ * Determine whether it is a special platform
+ *
+ * @private
+ */
+function getOs() {
+    if (typeof window === 'undefined') return {};
+
+    let os;
+
+    if ( typeof window !== "undefined" ) {
+    
+        const getOs = () => {
+            const _navigator: any = window.navigator;
+            const platform = () => {
+                // 2022 way of detecting. Note : this userAgentData feature is available only in secure contexts (HTTPS)
+                if (typeof _navigator.userAgentData !== 'undefined' && _navigator.userAgentData != null) {
+                    return _navigator.userAgentData.platform;
+                }
+                // Deprecated but still works for most of the browser
+                if (typeof _navigator.platform !== 'undefined') {
+                    if (typeof _navigator.userAgent !== 'undefined' && /android/.test(_navigator.userAgent.toLowerCase())) {
+                        // android device’s _navigator.platform is often set as 'linux', so const’s use userAgent for them
+                        return 'android';
+                    }
+                    return _navigator.platform;
+                }
+                return 'unknown';
+            }
+        
+            const _platform = platform().toLowerCase();
+        
+            const isOSX = /mac/.test(_platform); // Mac desktop
+            const isIOS = ['iphone', 'ipad', 'ipod'].indexOf(_platform) === -1 ? false : true; // Mac iOs
+            const isApple = isOSX || isIOS; // Apple device (desktop or iOS)
+            const isWindows = /win/.test(_platform); // Windows
+            const isAndroid = /android/.test(_platform); // Android
+            const isLinux = /linux/.test(_platform); // Linux
+        
+            return {
+                isOSX,
+                isIOS,
+                isApple,
+                isWindows,
+                isAndroid,
+                isLinux
+            }
+        
+        };
+    
+        os = getOs();
+    
+    } else {
+        os = {};
+    }
+    return os;
+
+}
+
+
+export default getOs;

package/publish/lib/esm/Utils/libs/performance.ts

@@ -0,0 +1,47 @@
+
+/*
+* Debounce
+*
+* @param  {Function} fn    - A function to be executed within the time limit.
+* @param  {Number} limit   - Waiting time.
+* @return {*}       - Returns a new function.
+*/  
+function debounce(fn: Function, limit: number = 300): any {
+    let timer: any;
+    return function(this: any) {
+        clearTimeout(timer);
+        timer = setTimeout(function(this: any) {
+            fn.apply(this, arguments);
+        }, limit);
+    }
+}
+
+
+
+
+
+/*
+* Throttle
+*
+* @param  {Function} fn    - A function to be executed within the time limit.
+* @param  {Number} limit   - Waiting time.
+* @return {*}       - Returns a new function.
+*/  
+function throttle(fn: Function, limit: number = 300): any {
+	let waiting: boolean = false;                     
+	return function (this: any) {                     
+		if (!waiting) {                 
+			fn.apply(this, arguments);  
+			waiting = true;                  
+			setTimeout(function () {          
+				waiting = false;           
+			}, limit);
+		}
+	}
+}
+
+
+export {
+    debounce,
+    throttle
+}

package/publish/lib/esm/Utils/libs/sanitize.ts

@@ -0,0 +1,55 @@
+
+/**
+ * HTML entities encode
+ *
+ * @param {String} str Input text
+ * @return {String} Filtered text
+ */function htmlEncode(str: string): string {
+
+    return str.replace(/[&<>'"]/g, tag => ({
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        "'": '&#39;',
+        '"': '&quot;'
+    }[tag]!));
+
+}
+
+
+/**
+ * HTML entities decode
+ *
+ * @param {String} str Input text
+ * @return {String} Filtered text
+ */
+function htmlDecode(str: string = ''): string {
+    const entities: [string, string][] = [
+        ['amp', '&'],
+        ['apos', '\''],
+        ['#x27', '\''],
+        ['#x2F', '/'],
+        ['#39', '\''],
+        ['#47', '/'],
+        ['lt', '<'],
+        ['gt', '>'],
+        ['nbsp', ' '],
+        ['quot', '"'],
+        ['#60', '<'],
+        ['#62', '>']
+    ];
+
+    for (let i = 0, max = entities.length; i < max; i++) {
+        str = str.replace(new RegExp('&' + entities[i][0] + ';', 'g'), entities[i][1]);
+    }
+
+    return str;
+}
+
+
+
+
+export {
+    htmlEncode,
+    htmlDecode
+}

package/publish/lib/esm/Utils/libs/time.ts

@@ -0,0 +1,139 @@
+
+
+/**
+ * Get timeslots from starting and ending time
+ * @param  {string} startTime  -  start time in format "HH:mm"
+ * @param  {string} endTime  -  end time in format "HH:mm"
+ * @param  {number} timeInterval  -  time interval in minutes
+ * @param  {boolean} formatRange  -  if true returns ranges like "10:00 - 11:00", if false returns single times like "10:00"
+ * @param  {boolean} forceShowSeconds  -  Whether to force the display of seconds. 
+ *                                        By default, seconds are displayed only when the timeInterval is less than 1
+ * @returns {string[]} Array of time slots
+ * @example
+
+console.log(getTimeslots("10:00", "14:00", 60, true)); //['10:00 - 11:00', '11:00 - 12:00', '12:00 - 13:00', '13:00 - 14:00']
+console.log(getTimeslots("10:00", "14:00", 60));   // ['10:00', '11:00', '12:00', '13:00']
+console.log(getTimeslots("10:00", "14:00", 60, false, true));   // ['10:00:00', '11:00:00', '12:00:00', '13:00:00', '14:00:00']
+console.log(getTimeslots("10:00", "10:07", 1.188118811881188));   // ['10:00', '10:01', '10:02', '10:03', '10:04', '10:05']
+console.log(getTimeslots("08:00:00", "08:02:00", 0.4));   // ['08:00:00', '08:00:24', '08:00:48', '08:01:12', '08:01:36', '08:02:00']
+
+*/
+
+function getTimeslots(
+    startTime: string,
+    endTime: string,
+    timeInterval: number,
+    formatRange: boolean = false,
+    forceShowSeconds = false
+): string[] {
+    // Parse time string to seconds
+    const parseTime = (s: string): number => {
+        const c = s.split(":").map(Number);
+        // Support HH:mm or HH:mm:ss
+        return c[0] * 3600 + c[1] * 60 + (c[2] || 0);
+    }
+
+    // Pad with zeros
+    const pad = (str: string | number, max: number): string => {
+        str = str.toString();
+        return str.length < max ? pad("0" + str, max) : str;
+    }
+
+    // Convert seconds to HH:mm or HH:mm:ss
+    const convertTime = (secs: number, showSeconds: boolean): string => {
+        const hour = Math.floor(secs / 3600);
+        const min = Math.floor((secs % 3600) / 60);
+        const sec = secs % 60;
+        if (showSeconds) {
+            return pad(hour, 2) + ":" + pad(min, 2) + ":" + pad(sec, 2);
+        } else {
+            return pad(hour, 2) + ":" + pad(min, 2);
+        }
+    }
+
+
+    // Seconds are displayed only when timeInterval < 1
+    const showSeconds = forceShowSeconds || timeInterval < 1;
+    const intervalInSeconds = showSeconds ? Math.round(timeInterval * 60) : timeInterval * 60;
+
+    // Calculate time slots
+    const calculateTimeSlot = (_startTime: number, _endTime: number, _timeInterval: number): string[] => {
+        const timeSlots: string[] = [];
+        let currentTime = _startTime;
+        while (currentTime <= _endTime) {
+            if (formatRange) {
+                const t = convertTime(currentTime, showSeconds) + ' - ' + convertTime(Math.min(currentTime + _timeInterval, _endTime), showSeconds);
+                timeSlots.push(t);
+            } else {
+                timeSlots.push(convertTime(currentTime, showSeconds));
+            }
+            currentTime += _timeInterval;
+        }
+        return timeSlots;
+    }
+
+    const inputStartTime = parseTime(startTime);
+    const inputEndTime = parseTime(endTime);
+
+    return calculateTimeSlot(inputStartTime, inputEndTime, intervalInSeconds);
+}
+
+
+
+/**
+ * Get minutes between two dates
+ * @param  {Date} startDate  -  start date
+ * @param  {Date} endDate  -  ebd date
+ * @returns Number
+ */
+function getMinutesBetweenDates(startDate: Date, endDate: Date) {
+    const diff = endDate.getTime() - startDate.getTime();
+    return (diff / 60000);
+}
+
+
+/**
+ * Get minutes between two time
+ * @param  {String} startTime  -  start time
+ * @param  {String} endTime  -  ebd time
+ * @returns Number
+ */
+function getMinutesBetweenTime(startTime: string, endTime: string) {
+    const pad = (num: string | number) => {
+        return ("0" + num).slice(-2);
+    };
+    let s: any = startTime.split(":"), sMin = +s[1] + s[0] * 60,
+        e: any = endTime.split(":"), eMin = +e[1] + e[0] * 60,
+        diff = eMin - sMin;
+        
+    if (diff < 0) { sMin -= 12 * 60; diff = eMin - sMin }
+    const h = Math.floor(diff / 60),
+        m = diff % 60;
+    return "" + pad(h) + ":" + pad(m);
+}
+
+
+
+/**
+ * Convert HH:MM:SS into minute
+ * @param  {String} timeStr  -  time string
+ * @returns Number
+ */
+function convertTimeToMin(timeStr: string) {
+    const _time = timeStr.split(':').length === 3 ?  `${timeStr}` : `${timeStr}:00`;
+
+    const res = _time.split(':'); // split it at the colons
+
+    // Hours are worth 60 minutes.
+    const minutes = (+res[0]) * 60 + (+res[1]);
+    return minutes;
+}
+
+
+export {
+    getTimeslots,
+    getMinutesBetweenDates,
+    getMinutesBetweenTime,
+    convertTimeToMin
+};
+