funda-ui 4.7.624 → 4.7.701

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

@@ -1,276 +0,0 @@
-
-
-/**
- * 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

@@ -1,68 +0,0 @@
-
-/**
- * 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

@@ -1,63 +0,0 @@
-
-
-/*
- * 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

@@ -1,47 +0,0 @@
-
-/*
-* 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

@@ -1,55 +0,0 @@
-
-/**
- * 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

@@ -1,139 +0,0 @@
-
-
-/**
- * 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
-};
-