funda-ui 4.5.682 → 4.5.711

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

@@ -0,0 +1,160 @@
+
+
+/**
+ * Gets the relative upside of the text
+ * @param {Element} el    - A DOM node containing one selector to match against.
+ * @returns {Number}      - Returns a pure number.
+ */
+function getTextTop(el: HTMLElement) {
+    const styles = window.getComputedStyle(el);
+    const fontSize = parseFloat(styles.fontSize);
+    const lineHeight = parseFloat(styles.lineHeight) || fontSize;
+    const paddingTop = parseFloat(styles.paddingTop);
+    const borderWidth = parseFloat(styles.borderWidth);
+
+    const textTop = paddingTop + (lineHeight - fontSize) / 2 - borderWidth*2;
+    return textTop;
+}
+
+/**
+* Get the actual value with user specific methed
+* it can be 'width', 'height', 'outerWidth', 'outerHeight'
+* @private
+* @param {Element} el           - A DOM node containing one selector to match against.
+* @param {String} prop          - A string naming the property of style.
+* @param {?Json} config         - Whether or not margin is included. The key `includeMargin` 
+                                    takes effect when set to true
+* @return {Number}              - Returns a pure number.
+*/
+function actualPropertyValue(el: any, prop: string, config: any = undefined) {
+    if (el === null) return 0;
+
+    const style = window.getComputedStyle ? window.getComputedStyle(el) : el.currentStyle,
+        display = style.display,
+        position = style.position,
+        visibility = style.visibility;
+
+    let marginWidth = 0;
+    let marginHeight = 0;
+
+    let maxVal: number;
+    let actualVal: any;
+
+
+    if (config && config.includeMargin === true) {
+        marginWidth = parseFloat(style.marginLeft) + parseFloat(style.marginRight);
+        marginHeight = parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+    }
+
+    if (prop === 'fontSize') {
+        actualVal = parseFloat(style.fontSize);
+    }
+
+    if (prop === 'fontFamily') {
+        actualVal = style.fontFamily;
+    }
+
+    if (prop === 'letterSpacing') {
+        actualVal = style.letterSpacing;
+    }
+    if (prop === 'width') {
+        maxVal = parseFloat(style.maxWidth);
+
+        // if its not hidden we just return normal height
+        if (display !== 'none' && maxVal !== 0) {
+            return el.clientWidth;
+        }
+    }
+    if (prop === 'height') {
+        maxVal = parseFloat(style.maxHeight);
+        if (display !== 'none' && maxVal !== 0) {
+            return el.clientHeight;
+        }
+    }
+
+    if (prop === 'outerWidth') {
+        maxVal = parseFloat(style.maxWidth);
+        if (display !== 'none' && maxVal !== 0) {
+            return el.offsetWidth + marginWidth;
+        }
+    }
+    if (prop === 'outerHeight') {
+        maxVal = parseFloat(style.maxHeight);
+        if (display !== 'none' && maxVal !== 0) {
+            return el.offsetHeight + marginHeight;
+        }
+    }
+
+    // the element is hidden so:
+    // making the el block so we can meassure its height but still be hidden
+    el.style.position = 'absolute';
+    el.style.visibility = 'hidden';
+    el.style.display = 'block';
+
+
+    if (prop === 'width') actualVal = el.clientWidth;
+    if (prop === 'height') actualVal = el.clientHeight;
+    if (prop === 'outerWidth') actualVal = el.offsetWidth + marginWidth;
+    if (prop === 'outerHeight') actualVal = el.offsetHeight + marginHeight;
+
+    // reverting to the original values
+    el.style.display = display;
+    el.style.position = position;
+    el.style.visibility = visibility;
+
+    return actualVal;
+}
+
+function getElCSS(input: HTMLElement, prop: any, isNumber: boolean) {
+    const val: any = document.defaultView?.getComputedStyle(input, null).getPropertyValue(prop);
+    return isNumber ? (isNaN(parseFloat(val)) ? 0 : parseFloat(val)) : val;
+}
+
+/**
+ * Get cursor or text position in pixels for input element
+ * 
+ * @param {HTMLInputElement} input  Required HTMLElement with `value` attribute
+ * @param {HTMLSpanElement} fauxContainer  Container of faux.
+     * @param {HTMLElement} rawTextContainer  The raw text container for the comparison
+ * @returns {Number}
+ */
+
+
+function getTextWidth(input: HTMLInputElement, fauxContainer: HTMLSpanElement, rawTextContainer: HTMLElement) {
+    if (input === null || fauxContainer === null || rawTextContainer === null) return 0;
+
+    const _off: any = input.selectionStart;
+    const _faux = fauxContainer;
+    const _fauxContainer = rawTextContainer;
+    if (_faux && _fauxContainer) {
+
+        // Styles to simulate a node in an input field
+        // use pre-wrap instead of wrap for white-space to support wrapping in textareas
+        const listOfModifiers = ['direction', 'font-family', 'font-size', 'font-size-adjust', 'font-variant', 'font-weight', 'font-style', 'letter-spacing', 'line-height', 'text-align', 'text-indent', 'text-transform', 'word-wrap', 'word-spacing'];
+
+        // default styles
+        _faux.style.setProperty('white-space', 'pre-wrap');
+        _faux.style.setProperty('padding', '0');
+        _faux.style.setProperty('margin', '0');
+        _faux.style.setProperty('display', 'none');
+
+        for (let i = 0; i < listOfModifiers.length; i++) {
+            const propertyValue = getElCSS(_fauxContainer, listOfModifiers[i], false);
+            _faux.style.setProperty(listOfModifiers[i], propertyValue);
+        }
+
+        _faux.textContent = input.value.substring(0, _off).replace(/\s/g, "\u00a0");
+        return actualPropertyValue(_faux, 'outerWidth');
+    }
+
+}
+
+
+export {
+    getElCSS,
+    getTextTop,
+    actualPropertyValue,
+    getTextWidth
+};
+
+

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
+}