diginet-core-ui 1.3.88 → 1.3.89

package/utils/usePortal.js

@@ -1,50 +1,44 @@
 import { useEffect, useRef } from 'react';
-/**
- * Create a element with id
- * @param {string} id 
- */
 
+/**
+ * Create a element with id
+ * @param {string} id 
+ */
 export const createEl = id => {
   const createdEl = document.createElement('div');
   createdEl.setAttribute('id', id);
   return createdEl;
 };
-/**
- * Insert into document.body at last
- * @param {Element} rootElem
- */
 
+/**
+ * Insert into document.body at last
+ * @param {Element} rootElem
+ */
 export const addRootEl = rootElem => {
   document.body.insertBefore(rootElem, document.body.lastElementChild.nextElementSibling);
 };
-/**
- * Create a portal with id
- * @param {string} id 
- */
 
+/**
+ * Create a portal with id
+ * @param {string} id 
+ */
 const usePortal = id => {
   const rootElemRef = useRef(null);
-
   const getRootEl = () => {
     if (!rootElemRef.current) {
       rootElemRef.current = document.createElement('div');
     }
-
     return rootElemRef.current;
   };
-
   useEffect(() => {
     const existingParent = document.querySelector(`#${id}`);
     const parentEl = existingParent || createEl(id);
-
     if (!existingParent) {
       addRootEl(parentEl);
     }
-
     parentEl.appendChild(rootElemRef.current);
     return () => {
       rootElemRef.current.remove();
-
       if (parentEl.childNodes.length === -1) {
         parentEl.remove();
       }
@@ -52,5 +46,4 @@ const usePortal = id => {
   }, []);
   return getRootEl();
 };
-
 export default usePortal;

package/utils/validate.js

@@ -1,26 +1,25 @@
 import { getGlobal } from "../global";
-/**
- * Validation the string is an valid email
- * @param {String} str The string to check an email
- * @param {String} message the error will return if str is not an email
- * @returns {Boolean} true if value is an email, message or default error if value is not an email
- */
 
+/**
+ * Validation the string is an valid email
+ * @param {String} str The string to check an email
+ * @param {String} message the error will return if str is not an email
+ * @returns {Boolean} true if value is an email, message or default error if value is not an email
+ */
 export const isEmail = (str, _, message) => {
   const re = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
   if (!nonNullish(str) || str === '') return true;
   return re.test(String(str).toLowerCase()) || (nonNullish(message) ? message : getGlobal(['validate', 'isEmail']));
 };
-/**
- * Validation value is not an empty string, array or object
- * @param {String|Object|Array} value the value to validate not empty
- * @param {String} message the error will return if value is empty
- * @returns {Boolean} true if value is not empty, message or default error if value is empty
- */
 
+/**
+ * Validation value is not an empty string, array or object
+ * @param {String|Object|Array} value the value to validate not empty
+ * @param {String} message the error will return if value is empty
+ * @returns {Boolean} true if value is not empty, message or default error if value is empty
+ */
 export const isNotEmpty = (value, _, message) => {
   if (!nonNullish(value)) return getGlobal(['validate', 'invalidInput']);
-
   if (typeof value === 'string') {
     return value !== '' || message || getGlobal(['validate', 'isNotEmptyString']);
   } else if (typeof value === 'object') {
@@ -30,54 +29,50 @@ export const isNotEmpty = (value, _, message) => {
       return Object.keys(value).length || message || getGlobal(['validate', 'isNotEmptyObject']);
     }
   }
-
   return true;
 };
-/**
- * Check a number is less than or equal the maximum allowed
- * @param {Number} value the value to compare with maximum
- * @param {Number} maximum the maximum value
- * @param {String} message the error will return if value > maximum
- * @returns {Boolean|String} true if value is valid, message or default error if invalid (both value and maximum)
- */
 
+/**
+ * Check a number is less than or equal the maximum allowed
+ * @param {Number} value the value to compare with maximum
+ * @param {Number} maximum the maximum value
+ * @param {String} message the error will return if value > maximum
+ * @returns {Boolean|String} true if value is valid, message or default error if invalid (both value and maximum)
+ */
 export const max = (value, maximum, message) => {
   if (!nonNullish([value, maximum]) || value === '') return true;
   if (isNaN(value) || isNaN(maximum)) return getGlobal(['validate', 'invalidInput']);
   return value <= maximum || (nonNullish(message) ? message : `${getGlobal(['validate', 'max'])} (${maximum})`);
 };
-/**
- * check a number is greater than or equal the minimum allowed
- * @param {Number} value the value to compare with minimize
- * @param {Number} minimize the minimize value
- * @param {String} message the error will return if value < minimize
- * @returns {Boolean|String} true if value is valid, message or default error if invalid (both value and minimize)
- */
 
+/**
+ * check a number is greater than or equal the minimum allowed
+ * @param {Number} value the value to compare with minimize
+ * @param {Number} minimize the minimize value
+ * @param {String} message the error will return if value < minimize
+ * @returns {Boolean|String} true if value is valid, message or default error if invalid (both value and minimize)
+ */
 export const min = (value, minimize, message) => {
   if (!nonNullish([value, minimize]) || value === '') return true;
   if (isNaN(value) || isNaN(minimize)) return getGlobal(['validate', 'invalidInput']);
   return value >= minimize || (nonNullish(message) ? message : `${getGlobal(['validate', 'min'])} (${minimize})`);
 };
-/**
- * check value has anything
- * @param {String|Number|Object} value the value to check
- * @param {String} message the error will return if undefined|null|empty
- * @returns {Boolean|String} true if value is valid, message input or default error if value invalid
- */
 
+/**
+ * check value has anything
+ * @param {String|Number|Object} value the value to check
+ * @param {String} message the error will return if undefined|null|empty
+ * @returns {Boolean|String} true if value is valid, message input or default error if value invalid
+ */
 export const required = (value, message) => {
   return nonNullish(value) && value !== '' || (nonNullish(message) ? message : getGlobal(['validate', 'required']));
 };
-
 const nonNullish = value => {
   if (Array.isArray(value)) {
     return value.every(v => v !== undefined && v !== null);
   }
-
   return value !== undefined && value !== null;
 };
-
 const validations = {
   isEmail,
   isNotEmpty,
@@ -85,48 +80,42 @@ const validations = {
   min,
   required
 };
-/**
- * validation value follow rule(s)
- * @param {String|Number|Object|Array} value the value to validate
- * @param {String|Object|Array} rules the rule(s) to validation value
- * @param {Boolean} returnOneError only return first error if have errors
- * @returns {Boolean|String|Array} true if value is valid, error text or an array error if invalid value
- */
 
+/**
+ * validation value follow rule(s)
+ * @param {String|Number|Object|Array} value the value to validate
+ * @param {String|Object|Array} rules the rule(s) to validation value
+ * @param {Boolean} returnOneError only return first error if have errors
+ * @returns {Boolean|String|Array} true if value is valid, error text or an array error if invalid value
+ */
 const onValidate = (value, rules, returnOneError) => {
   if (!rules) return true;
   let result = true;
-
   if (typeof rules === 'function') {
     result = rules(value);
   } else if (typeof rules === 'object') {
     if (Array.isArray(rules)) {
       rules.forEach(rule => {
         let res;
-
         if (typeof rule === 'string') {
           res = validations[rule](value);
         } else {
           const name = rule.name || Object.keys(rule)[0];
           const compareValue = rule.compareValue !== undefined ? rule.compareValue : rule[name];
-
           if (name && validations[name]) {
             res = validations[name](value, compareValue, rule.message);
           }
         }
-
         if (res !== true) {
           if (result === true) {
             result = [];
           }
-
           result.push(res);
         }
       });
     } else {
       const name = rules.name || Object.keys(rules)[0];
       const compareValue = rules.compareValue !== undefined ? rules.compareValue : rules[name];
-
       if (name) {
         result = validations[name](value, compareValue, rules.message);
       }
@@ -134,7 +123,6 @@ const onValidate = (value, rules, returnOneError) => {
   } else if (validations[rules]) {
     result = validations[rules](value);
   }
-
   if (returnOneError) {
     if (result === true) {
       return false;
@@ -142,8 +130,6 @@ const onValidate = (value, rules, returnOneError) => {
       return result;
     } else return result[0];
   }
-
   return result;
 };
-
 export default onValidate;