funda-ui 4.5.682 → 4.5.711

package/publish/lib/cjs/Utils/math.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Evaluating a string as a mathematical expression
+ * @param {String} s      - An input string
+ * @returns {Number}   - New calculation result.
+ */
+declare function evaluate(s: string): number;
+/**
+ * Addition
+ * @param {Number} num1
+ * @param {Number} num2
+ * @return {Number}
+ */
+declare function calcAdd(num1: number, num2: number): number;
+/**
+ * Subtraction
+ * @param {Number} num1
+ * @param {Number} num2
+ * @return {Number}
+ */
+declare function calcSub(num1: number, num2: number): string;
+/**
+ * Multiplication
+ * @param {Number} num1
+ * @param {Number} num2
+ * @return {Number}
+ */
+declare function calcMul(num1: number, num2: number): number;
+/**
+ * Division
+ * @param {Number} num1
+ * @param {Number} num2
+ * @return {Number}
+ */
+declare function calcDiv(num1: number, num2: number): number;
+/**
+ * Determine if it's a number
+ * @param {*} n
+ * @returns {Boolean}
+ */
+declare function isNumeric(s: any): boolean;
+/**
+ * Determine if it's a decimal
+ * @param {Number} num
+ * @returns {Boolean}
+ */
+declare function isDecimal(num: number): boolean;
+/**
+ * Truncate Decimals
+ * @param {Number} num
+ * @param {Number} decimalPlaces
+ * @returns {Number}
+ */
+declare function truncateDecimals(num: number, decimalPlaces: number): number;
+/**
+ * Zero Pad
+ * @param {Number|String} n
+ * @param {?Number} decimalPlaces
+ * @returns {String}
+ */
+declare function numZeroPad(n: number | string, decimalPlaces?: number): string;
+/**
+ * Check whether the number of decimal places exceeds the specified value
+ * @param {Number|String} s
+ * @param {Number} decimalPlaces
+ * @returns {Boolean}
+ */
+declare function exceedDecimalPlaces(s: string | number, decimalPlaces: number): boolean | "";
+/**
+ * Format number
+ * @param {*} inputValue
+ * @param {?Number} decimalPlaces
+ * @param {Number|undefined} inputMin
+ * @param {Number|undefined} inputMax
+ * @returns {String}
+ */
+declare function formatNumber(inputValue: any, decimalPlaces?: number, inputMin?: number | undefined, inputMax?: number | undefined): string;
+export { evaluate, calcAdd, calcSub, calcMul, calcDiv, isNumeric, isDecimal, truncateDecimals, numZeroPad, exceedDecimalPlaces, formatNumber };

package/publish/lib/cjs/Utils/math.js

@@ -0,0 +1,305 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["RPB"] = factory();
+	else
+		root["RPB"] = factory();
+})(this, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	var __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "calcAdd": () => (/* binding */ calcAdd),
+/* harmony export */   "calcDiv": () => (/* binding */ calcDiv),
+/* harmony export */   "calcMul": () => (/* binding */ calcMul),
+/* harmony export */   "calcSub": () => (/* binding */ calcSub),
+/* harmony export */   "evaluate": () => (/* binding */ evaluate),
+/* harmony export */   "exceedDecimalPlaces": () => (/* binding */ exceedDecimalPlaces),
+/* harmony export */   "formatNumber": () => (/* binding */ formatNumber),
+/* harmony export */   "isDecimal": () => (/* binding */ isDecimal),
+/* harmony export */   "isNumeric": () => (/* binding */ isNumeric),
+/* harmony export */   "numZeroPad": () => (/* binding */ numZeroPad),
+/* harmony export */   "truncateDecimals": () => (/* binding */ truncateDecimals)
+/* harmony export */ });
+/**
+ * Evaluating a string as a mathematical expression
+ * @param {String} s      - An input string
+ * @returns {Number}   - New calculation result.
+ */
+function evaluate(s) {
+  var chars = s.replace(/\s/g, '').split("");
+  var n = [],
+    op = [],
+    index = 0,
+    oplast = true;
+  n[index] = "";
+
+  // Parse the expression
+  for (var 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
+  var resStr = parseFloat(n[0]);
+  for (var o = 0; o < op.length; o++) {
+    var 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, num2) {
+  var 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, num2) {
+  var baseNum, baseNum1, baseNum2;
+  var 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, num2) {
+  var 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, num2) {
+  var baseNum1 = 0,
+    baseNum2 = 0;
+  var 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) {
+  return !isNaN(parseFloat(s)) && isFinite(s);
+}
+
+/**
+ * Determine if it's a decimal
+ * @param {Number} num
+ * @returns {Boolean}
+ */
+function isDecimal(num) {
+  return num !== Math.floor(num);
+}
+
+/**
+ * Truncate Decimals
+ * @param {Number} num 
+ * @param {Number} decimalPlaces 
+ * @returns {Number}
+ */
+function truncateDecimals(num, decimalPlaces) {
+  var 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) {
+  var decimalPlaces = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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, decimalPlaces) {
+  var 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) {
+  var decimalPlaces = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var inputMin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+  var inputMax = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 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
+  var formattedValue = String(inputValue).replace(/[^0-9.\-]/g, "");
+
+  // STEP 4
+  // =================================================================
+  // Prevent multiple decimal points
+  var parts = formattedValue.split(".");
+  if (parts.length > 2) {
+    formattedValue = "".concat(parts[0], ".").concat(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;
+}
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/publish/lib/cjs/Utils/object.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Remove Duplicate objects from JSON Array
+ * @param {Array} obj
+ * @param {String} fieldName
+ */
+declare function removeArrDuplicateItems(obj: any[], fieldName: string): any[];
+/**
+ * Deep clone
+ * @param {*} obj
+ */
+declare function deepClone(obj: any): any;
+/**
+ * Flat Data
+ * @param {*} data
+ * @returns
+ */
+declare function flatData(data: any): any[];
+export { removeArrDuplicateItems, deepClone, flatData };

package/publish/lib/cjs/Utils/object.js

@@ -0,0 +1,120 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["RPB"] = factory();
+	else
+		root["RPB"] = factory();
+})(this, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	var __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "deepClone": () => (/* binding */ deepClone),
+/* harmony export */   "flatData": () => (/* binding */ flatData),
+/* harmony export */   "removeArrDuplicateItems": () => (/* binding */ removeArrDuplicateItems)
+/* harmony export */ });
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+/**
+ * Remove Duplicate objects from JSON Array
+ * @param {Array} obj 
+ * @param {String} fieldName 
+ */
+function removeArrDuplicateItems(obj, fieldName) {
+  if (!Array.isArray(obj)) return [];
+  var clean = obj.filter(function (item, index, self) {
+    return index === self.findIndex(function (t) {
+      return t[fieldName] === item[fieldName];
+    });
+  });
+  return clean;
+}
+;
+
+/**
+ * Deep clone
+ * @param {*} obj 
+ */
+function deepClone(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(function (item) {
+      return deepClone(item);
+    });
+  } else if (_typeof(obj) === 'object' && obj !== null) {
+    var clone = {};
+    for (var 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) {
+  var result = [];
+  var iterate = function iterate(obj) {
+    if (!obj) {
+      return;
+    }
+    obj.forEach(function (item) {
+      result.push(item);
+      if (item.children) {
+        iterate(item.children);
+      }
+
+      // delete current item children
+      delete item.children;
+    });
+  };
+  iterate(data);
+  return result;
+}
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/publish/lib/cjs/Utils/os.d.ts

@@ -0,0 +1,2 @@
+declare function getOs(): any;
+export default getOs;

package/publish/lib/cjs/Utils/os.js

@@ -0,0 +1,104 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["RPB"] = factory();
+	else
+		root["RPB"] = factory();
+})(this, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	var __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/*
+ * Determine whether it is a special platform
+ *
+ * @private
+ */
+function getOs() {
+  if (typeof window === 'undefined') return {};
+  var os;
+  if (typeof window !== "undefined") {
+    var _getOs = function _getOs() {
+      var _navigator = window.navigator;
+      var platform = function 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';
+      };
+      var _platform = platform().toLowerCase();
+      var isOSX = /mac/.test(_platform); // Mac desktop
+      var isIOS = ['iphone', 'ipad', 'ipod'].indexOf(_platform) === -1 ? false : true; // Mac iOs
+      var isApple = isOSX || isIOS; // Apple device (desktop or iOS)
+      var isWindows = /win/.test(_platform); // Windows
+      var isAndroid = /android/.test(_platform); // Android
+      var isLinux = /linux/.test(_platform); // Linux
+
+      return {
+        isOSX: isOSX,
+        isIOS: isIOS,
+        isApple: isApple,
+        isWindows: isWindows,
+        isAndroid: isAndroid,
+        isLinux: isLinux
+      };
+    };
+    os = _getOs();
+  } else {
+    os = {};
+  }
+  return os;
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getOs);
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/publish/lib/cjs/Utils/performance.d.ts

@@ -0,0 +1,3 @@
+declare function debounce(fn: Function, limit?: number): any;
+declare function throttle(fn: Function, limit?: number): any;
+export { debounce, throttle };