diginet-core-ui 1.3.24

package/utils/number.js

@@ -0,0 +1,64 @@
+/**
+ * 
+ * @param {String} value 
+ * @param {String} format
+*/
+export default function numberFormat(value, format) {
+  let hashCount = 0;
+  let a = '';
+
+  for (let i = 0, ln = format.length; i < ln; i++) {
+    if (format[i] === '.') {
+      format1 = format.split('.');
+      console.log(format1);
+
+      if (format1 = format.split('.').length === 3) {
+        console.log('a');
+      } else {
+        hashCount = format1[1].length;
+
+        switch (hashCount) {
+          case 3:
+            a = value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+            break;
+
+          case 2:
+            a = value.toString().replace(/\B(?=(\d{2})+(?!\d))/g, ",");
+            break;
+
+          default:
+            return 'Invalid format';
+        }
+
+        return a;
+      }
+    }
+
+    if (format[i] === ' ') {
+      const formatArray = format.split('#').filter(str => str !== '');
+      let start = 0;
+      let numStr = '';
+
+      for (let i = 0, ln = format.length; i <= ln; i++) {
+        const part = formatArray[i] || ''; //if i is the last fragment take the index of end of the value
+        //For case like +1 (911) 911 91 91 having pattern +1 (###) ### ## ##
+
+        const index = i === ln ? value.length : value.indexOf(part, start);
+        /* in any case if we don't find the pattern part in the value assume the val as numeric string
+        This will be also in case if user has started typing, in any other case it will not be -1
+        unless wrong prop value is provided */
+
+        if (index === -1) {
+          numStr = value;
+          break;
+        } else {
+          numStr += val.substring(start, index);
+          start = index + part.length;
+        }
+      }
+
+      return (numStr.toString() || []).replace(/\B(?=(\d{4})+(?!\d))/g, " ");
+    }
+  }
+}
+;

package/utils/object/extend.js

@@ -0,0 +1,57 @@
+import { isPlainObject } from '../type';
+export const extendFromObject = (target = {}, source, overrideExistingValues) => {
+  for (const prop in source) {
+    if (Object.prototype.hasOwnProperty.call(source, prop)) {
+      const value = source[prop];
+
+      if (!(prop in target) || overrideExistingValues) {
+        target[prop] = value;
+      }
+    }
+  }
+
+  return target;
+};
+export const extend = function (target = {}) {
+  let i = 1;
+  let deep = false;
+
+  if (typeof target === 'boolean') {
+    deep = target;
+    target = arguments[1] || {};
+    i++;
+  }
+
+  for (; i < arguments.length; i++) {
+    const source = arguments[i];
+
+    if (source == null) {
+      continue;
+    }
+
+    for (const key in source) {
+      const targetValue = target[key];
+      const sourceValue = source[key];
+      let sourceValueIsArray = false;
+      let clone;
+
+      if (key === '__proto__' || key === 'constructor' || target === sourceValue) {
+        continue;
+      }
+
+      if (deep && sourceValue && (isPlainObject(sourceValue) || (sourceValueIsArray = Array.isArray(sourceValue)))) {
+        if (sourceValueIsArray) {
+          clone = targetValue && Array.isArray(targetValue) ? targetValue : [];
+        } else {
+          clone = targetValue && isPlainObject(targetValue) ? targetValue : {};
+        }
+
+        target[key] = extend(deep, clone, sourceValue);
+      } else if (sourceValue !== undefined) {
+        target[key] = sourceValue;
+      }
+    }
+  }
+
+  return target;
+};

package/utils/object/object.js

@@ -0,0 +1,68 @@
+import { isNumeric } from '../type'; // import { isNumeric, isPlainObject, isObject } from './type';
+// import variableWrapper from './variable_wrapper';
+
+const clone = (() => {
+  function Clone() {}
+
+  return obj => {
+    Clone.prototype = obj;
+    return new Clone();
+  };
+})();
+
+const orderEach = function (map, func) {
+  const keys = [];
+  let key;
+  let i;
+
+  for (key in map) {
+    if (Object.prototype.hasOwnProperty.call(map, key)) {
+      keys.push(key);
+    }
+  }
+
+  keys.sort((x, y) => {
+    const isNumberX = isNumeric(x);
+    const isNumberY = isNumeric(y);
+    if (isNumberX && isNumberY) return x - y;
+    if (isNumberX && !isNumberY) return -1;
+    if (!isNumberX && isNumberY) return 1;
+    if (x < y) return -1;
+    if (x > y) return 1;
+    return 0;
+  });
+
+  for (i = 0; i < keys.length; i++) {
+    key = keys[i];
+    func(key, map[key]);
+  }
+}; // const assignValueToProperty = ( target, property, value, assignByReference ) => {
+// 	if (!assignByReference && variableWrapper.isWrapped(target[property])) {
+// 		variableWrapper.assign(target[property], value);
+// 	} else {
+// 		target[property] = value;
+// 	}
+// };
+// // B239679, http://bugs.jquery.com/ticket/9477
+// const deepExtendArraySafe = ( target, changes, extendComplexObject, assignByReference ) => {
+// 	let prevValue;
+// 	let newValue;
+// 	for (const name in changes) {
+// 		prevValue = target[name];
+// 		newValue = changes[name];
+// 		if ( name === '__proto__' || name === 'constructor' || target === newValue ) { continue; }
+// 		if (isPlainObject(newValue)) {
+// 			const goDeeper = extendComplexObject ? isObject(prevValue) : isPlainObject(prevValue);
+// 			newValue = deepExtendArraySafe( goDeeper ? prevValue : {}, newValue, extendComplexObject, assignByReference );
+// 		}
+// 		if (newValue !== undefined && prevValue !== newValue) {
+// 			assignValueToProperty(target, name, newValue, assignByReference);
+// 		}
+// 	}
+// 	return target;
+// };
+
+
+export { clone, orderEach
+/**, deepExtendArraySafe */
+};

package/utils/parseHTML.js

@@ -0,0 +1,8 @@
+const parseHTML = (text, output = 'innerHTML') => {
+  if (!text) return null;
+  const DOM = new DOMParser().parseFromString(text, 'text/html').querySelector('body');
+  const result = DOM[output];
+  return result && result.trim ? result.trim() : result;
+};
+
+export default parseHTML;

package/utils/promisify.js

@@ -0,0 +1,38 @@
+const slice = Array.prototype.slice;
+let Promise;
+
+if (typeof window !== 'undefined') {
+  Promise = window.Promise;
+}
+
+if (typeof global !== 'undefined') {
+  Promise = global.Promise;
+}
+
+function promisify(func) {
+  if (Promise) {
+    return function () {
+      const args = slice.call(arguments);
+      const ctx = this;
+
+      if (typeof args.slice(-1) === 'function') {
+        return func.apply(ctx, args);
+      } else {
+        return new Promise(function (resolve, reject) {
+          args.push(function (err, result) {
+            if (err) {
+              reject(err);
+            } else {
+              resolve.apply(this, slice.call(arguments, 1));
+            }
+          });
+          func.apply(ctx, args);
+        });
+      }
+    };
+  } else {
+    return func;
+  }
+}
+
+export default promisify;

package/utils/randomString.js

@@ -0,0 +1,33 @@
+export default function getRandomString(length = 10, options = {}) {
+  const {
+    allowNumber = true,
+    allowLowercase = true,
+    allowUppercase = true,
+    allowSymbol = true
+  } = options;
+  let string = '';
+
+  if (allowNumber) {
+    string += '0123456789';
+  }
+
+  if (allowLowercase) {
+    string += 'abcdefghijklmnopqrstuvwxyz';
+  }
+
+  if (allowUppercase) {
+    string += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  }
+
+  if (allowSymbol) {
+    string += '@$%^&*_+-';
+  }
+
+  let newString = '';
+
+  for (let i = 0; i < length; i++) {
+    newString += string[Math.floor(Math.random() * string.length)];
+  }
+
+  return newString;
+}

package/utils/remove-unicode.js

@@ -0,0 +1,6 @@
+const removeUnicode = (str, spaceTo = ' ') => {
+  if (!str || typeof str !== 'string') return str;
+  return str.replace(/à|á|ạ|ả|ã|â|ầ|ấ|ậ|ẩ|ẫ|ă|ằ|ắ|ặ|ẳ|ẵ/gi, "a").replace(/è|é|ẹ|ẻ|ẽ|ê|ề|ế|ệ|ể|ễ/gi, "e").replace(/ì|í|ị|ỉ|ĩ/gi, "i").replace(/ò|ó|ọ|ỏ|õ|ô|ồ|ố|ộ|ổ|ỗ|ơ|ờ|ớ|ợ|ở|ỡ/gi, "o").replace(/ù|ú|ụ|ủ|ũ|ư|ừ|ứ|ự|ử|ữ/gi, "u").replace(/ỳ|ý|ỵ|ỷ|ỹ/gi, "y").replace(/đ/gi, "d").replaceAll(' ', spaceTo);
+};
+
+export default removeUnicode;

package/utils/render-portal.js

@@ -0,0 +1,90 @@
+import { Children } from 'react';
+import { render, createPortal } from 'react-dom';
+const idPortal = 'DGN-UI-Portal',
+      classNameCommon = 'DGN-UI-Portal';
+export const getPortal = () => {
+  const portal = document.getElementById(idPortal);
+  if (portal) return portal;
+  const node = document.createElement('div');
+  node.id = idPortal;
+  node.style.cssText = 'position: fixed; inset: 0; pointer-events: none; z-index: 9000;';
+  return document.body.appendChild(node);
+};
+export const isLastChildNode = node => {
+  if (!node) return false;
+
+  if (typeof node === 'string') {
+    node = document.querySelector(node);
+  } else {
+    node = node.current || node.target || node;
+  }
+
+  const portal = getPortal();
+  const length = portal.childNodes.length;
+  return length && portal.lastChild.contains(node);
+};
+export const renderPortal = (node, containers, isCreate = false, options = {}) => {
+  const {
+    style = {},
+    className
+  } = options;
+  let container = getPortal();
+  Object.assign(container, style);
+
+  if (className) {
+    container.classList.add(className);
+  }
+
+  if (containers) {
+    containers.classList.add(classNameCommon);
+    containers.style.pointerEvents = 'auto';
+    container = container.appendChild(containers);
+
+    if (isCreate) {
+      return /*#__PURE__*/createPortal(node, container);
+    } else {
+      render(node, container);
+    }
+  } else {
+    Children.forEach(node, containerChild => {
+      const parent = document.createElement(containerChild.type);
+      const children = containerChild.props.children;
+      Object.keys(containerChild.props).forEach(key => {
+        if (!/__EMOTION_TYPE_PLEASE_DO_NOT_USE__|children/.test(key)) {
+          if (key === 'css') {
+            parent.classList.add(`css-${containerChild.props[key].name}`);
+          } else if (key === 'style') {
+            Object.assign(parent.style, containerChild.props[key]);
+          } else {
+            parent[key] = containerChild.props[key];
+          }
+        }
+      });
+      parent.classList.add(classNameCommon);
+      parent.style.pointerEvents = 'auto';
+      container = container.appendChild(parent);
+
+      if (isCreate) {
+        return /*#__PURE__*/createPortal(children, container);
+      } else {
+        render(children, container);
+      }
+    });
+  }
+};
+export const removePortal = node => {
+  if (isLastChildNode(node)) {
+    node.remove();
+    removePortalCommon();
+    return true;
+  }
+
+  return false;
+};
+export const removePortalCommon = () => {
+  const portals = getPortal();
+
+  if (!portals.childNodes.length) {
+    portals.remove();
+  }
+};

package/utils/renderHTML.js

@@ -0,0 +1,21 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+/** @jsxRuntime classic */
+
+/** @jsx jsx */
+import { jsx } from '@emotion/core';
+import parseTextToHTML from './parseHTML';
+
+const renderHTML = (text = null, TagName = 'div', options = {}) => {
+  if (text && (text.$$typeof && String(text.$$typeof) === 'Symbol(react.element)' || Array.isArray(text) && text.some(node => node && String(node.$$typeof) === 'Symbol(react.element)'))) {
+    return jsx(TagName, options, text);
+  }
+
+  return jsx(TagName, _extends({}, options, {
+    dangerouslySetInnerHTML: {
+      __html: parseTextToHTML(String(text))
+    }
+  }));
+};
+
+export default renderHTML;

package/utils/renderIcon.js

@@ -0,0 +1,57 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+/** @jsxRuntime classic */
+
+/** @jsx jsx */
+import { jsx } from '@emotion/core';
+import Icon, * as Icons from '../icons';
+import { parseTextToHTML, capitalize } from './';
+/**
+ * render icon form source (dynamic type)
+ * @param {String|jsx} source data of icon, maybe svg text | image link | name of icon in icons store or a jsx element
+ * @param {String} type text to parse text to HTML, img link to use img tag, name to use icon form icons store
+ * @param {Object} options properties of Icon component if us type is name {width, height, color, viewBox, ...}
+ */
+
+const renderIcon = (source, type, options = {}) => {
+  if (typeof source === 'string') {
+    switch (type) {
+      case 'name':
+        let IconComp = Icons[capitalize(source)];
+
+        if (IconComp) {
+          return jsx(IconComp, options);
+        }
+
+        return null;
+
+      case 'effect':
+        return jsx(Icon, _extends({
+          name: source
+        }, options));
+
+      case 'link':
+      case 'imgLink':
+        return jsx("img", _extends({
+          src: source
+        }, options));
+
+      default:
+        if (source.length < 20) {
+          const IconComp = Icons[capitalize(source)];
+
+          if (IconComp) {
+            return jsx(IconComp, options);
+          }
+
+          return null;
+        }
+
+        return parseTextToHTML(source, options.output || options);
+    }
+  }
+
+  return source;
+};
+
+export default renderIcon;