diginet-core-ui 1.3.87 → 1.3.88

package/utils/array/array.js

@@ -1,93 +1,100 @@
 import { isDefined } from "../type";
 import { each } from "../iterator";
 import { orderEach } from "../object/object";
-
-/**
- *
- * @param {any} entity
- * @returns {Array} [entity]
+/**
+ *
+ * @param {any} entity
+ * @returns {Array} [entity]
  */
-export const wrapToArray = entity => Array.isArray(entity) ? entity : [entity];
 
-/**
- *
- * @param {*} value in object
- * @param {ArrayLike} object is a array-like object
- * @returns {Number} index of value, -1 if not found
+export const wrapToArray = entity => Array.isArray(entity) ? entity : [entity];
+/**
+ *
+ * @param {*} value in object
+ * @param {ArrayLike} object is a array-like object
+ * @returns {Number} index of value, -1 if not found
  */
+
 export const inArray = (value, object) => {
   if (!object) return -1;
   const array = Array.isArray(object) ? object : Array.from(object);
   return array.indexOf(value);
 };
-
-/**
- *
- * @param {Array} a
- * @param {Array} b
- * @returns {Array} intersection array of a and b
+/**
+ *
+ * @param {Array} a
+ * @param {Array} b
+ * @returns {Array} intersection array of a and b
  */
+
 export const intersection = (a, b) => {
   if (!Array.isArray(a) || a.length === 0 || !Array.isArray(b) || b.length === 0) return [];
   const result = [];
   each(a, (_, value) => {
     const index = inArray(value, b);
+
     if (index !== -1) {
       result.push(value);
     }
   });
   return result;
 };
-
-/**
- *
- * @param {Array} data
- * @returns {Array} array with unique values
+/**
+ *
+ * @param {Array} data
+ * @returns {Array} array with unique values
  */
-export const uniqueValues = data => data.filter((item, position) => data.indexOf(item) === position);
 
-/**
- *
- * @param {Array} from
- * @param {Array} what
- * @returns {Array} without duplicate
+export const uniqueValues = data => data.filter((item, position) => data.indexOf(item) === position);
+/**
+ *
+ * @param {Array} from
+ * @param {Array} what
+ * @returns {Array} without duplicate
  */
+
 export const removeDuplicates = function (from, what) {
   if (!Array.isArray(from) || from.length === 0) {
     return [];
   }
+
   if (!Array.isArray(what) || what.length === 0) {
     return from.slice();
   }
+
   const result = [];
   each(from, (_, value) => {
     const index = inArray(value, what);
+
     if (index === -1) {
       result.push(value);
     }
   });
   return result;
 };
-
-/**
- *
- * @param {Array} items
- * @param {*} indexParameterName
- * @param {*} currentItem
- * @param {Function} needIndexCallback
- * @returns
+/**
+ *
+ * @param {Array} items
+ * @param {*} indexParameterName
+ * @param {*} currentItem
+ * @param {Function} needIndexCallback
+ * @returns
  */
+
 export const normalizeIndexes = function (items, indexParameterName, currentItem, needIndexCallback) {
   const indexedItems = {};
   let parameterIndex = 0;
-  /**
-   * useLegacyVisibleIndex will be process in future
+  /**
+   * useLegacyVisibleIndex will be process in future
    */
+
   const useLegacyVisibleIndex = false;
   each(items, (index, item) => {
     index = item[indexParameterName];
+
     if (index >= 0) {
       indexedItems[index] = indexedItems[index] || [];
+
       if (item === currentItem) {
         indexedItems[index].unshift(item);
       } else {
@@ -97,17 +104,20 @@ export const normalizeIndexes = function (items, indexParameterName, currentItem
       item[indexParameterName] = undefined;
     }
   });
+
   if (!useLegacyVisibleIndex) {
     each(items, function () {
       if (!isDefined(this[indexParameterName]) && !!needIndexCallback && needIndexCallback(this)) {
         while (indexedItems[parameterIndex]) {
           parameterIndex++;
         }
+
         indexedItems[parameterIndex] = [this];
         parameterIndex++;
       }
     });
   }
+
   parameterIndex = 0;
   orderEach(indexedItems, function (index, items) {
     each(items, function () {
@@ -115,9 +125,7 @@ export const normalizeIndexes = function (items, indexParameterName, currentItem
         this[indexParameterName] = parameterIndex++;
       }
     });
-  });
-
-  // if (useLegacyVisibleIndex) {
+  }); // if (useLegacyVisibleIndex) {
   // 	each(items, function () {
   // 		if (
   // 			!isDefined(this[indexParameterName]) &&
@@ -134,6 +142,7 @@ export const merge = function (array1, array2) {
   for (let i = 0; i < array2.length; i++) {
     array1[array1.length] = array2[i];
   }
+
   return array1;
 };
 export const find = function (array, condition) {
@@ -143,8 +152,7 @@ export const find = function (array, condition) {
     }
   }
 };
-export const groupByFunc = (array, cb) => array.reduce((result, item) => ({
-  ...result,
+export const groupByFunc = (array, cb) => array.reduce((result, item) => ({ ...result,
   [cb(item)]: [...(result[cb(item)] || []), item]
 }), {});
 export const groupByKey = (array, key) => array.reduce((result, item) => {
@@ -154,6 +162,7 @@ export const groupByKey = (array, key) => array.reduce((result, item) => {
 export const isEqual = (currentArray, compareArray) => {
   if (!currentArray || !compareArray) return false;
   if (currentArray.length !== compareArray.length) return false;
+
   for (let i = 0, j = currentArray.length; i < j; i++) {
     if (currentArray[i] instanceof Array && compareArray[i] instanceof Array) {
       if (!isEqual(currentArray[i], compareArray[i])) {
@@ -161,9 +170,9 @@ export const isEqual = (currentArray, compareArray) => {
       }
     } else if (currentArray[i] !== compareArray[i]) {
       return false;
-    }
-    // in future will update for object case
+    } // in future will update for object case
     // else if (typeof currentArray[i] === 'object' && typeof compareArray[i] === 'object') {}
+
   }
 
   return true;

package/utils/{classNames.js → classNames/index.js}

@@ -1,11 +1,14 @@
 const hasOwn = {}.hasOwnProperty;
+
 const classNames = (...args) => {
   args = args.flat();
   let classes = [];
+
   for (let i = 0; i < args.length; i++) {
     let arg = args[i];
     if (!arg) continue;
     let argType = typeof arg;
+
     if (argType === 'string' || argType === 'number') {
       classes.push(arg);
     } else if (argType === 'object') {
@@ -20,6 +23,8 @@ const classNames = (...args) => {
       }
     }
   }
+
   return classes.join(' ');
 };
+
 export default classNames;

package/utils/console.js

@@ -1,11 +1,15 @@
 import { isFunction } from "./type";
+
 const noop = () => {};
+
 const getConsoleMethod = function (method) {
   if (typeof console === 'undefined' || !isFunction(console[method])) {
     return noop;
   }
+
   return console[method].bind(console);
 };
+
 export const logger = {
   info: getConsoleMethod('info'),
   warn: getConsoleMethod('warn'),
@@ -17,9 +21,11 @@ export const debug = (() => {
       throw new Error(message);
     }
   };
+
   const assertParam = (parameter, message) => {
     assert(parameter !== null && parameter !== undefined, message);
   };
+
   return {
     assert: assert,
     assertParam: assertParam