@zohodesk/utils 1.0.0-temp-1

package/README.md

@@ -0,0 +1,42 @@
+# DOT - Util Collections
+
+In this package, We provide lots of util fuctions for web devlopment
+
+# 1.3.16
+
+- `getCurrentTime`, `objectCRUD`, `arrayCRUD`, `deepEqual`, `ArrayManager`, `ObjectManager` util added.
+
+# 1.3.15
+
+- **renderNodeUtils**
+- `renderNode` function added to render content that can be either a function or a React element.
+- `isRenderable` function added to check if the content is renderable (either a function or a valid React element).
+
+# 1.3.14
+
+- **StringUtils**
+- String Utils Methods added
+
+# 1.3.13
+
+- `mergeStyle` issue fix
+
+# 1.3.12
+
+- `mergeStyle` functionality updated. Composed classes will also update if it is inside that file.
+```js
+// Before
+const style = mergeStyle(
+    { a: '1', b: '1 2' },
+    { a: 'a' } 
+);
+// style = { a: '1 a', b: '1 2' }
+
+// After
+const style = mergeStyle(
+    { a: '1', b: '1 2' },
+    { a: 'a' } 
+);
+// style = { a: '1 a', b: '1 a 2' }
+```
+- `compileClassNames` code optimized. Will not support other than object as argument.

package/es/ErrorBoundary.js

@@ -0,0 +1,29 @@
+import React from 'react';
+export default class ErrorBoundary extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      hasError: false
+    };
+  }
+
+  static getDerivedStateFromError(error) {
+    return {
+      hasError: true,
+      error
+    };
+  }
+
+  componentDidCatch(error, errorInfo) {
+    console.log(error, errorInfo);
+  }
+
+  render() {
+    if (this.state.hasError) {
+      return this.props.renderFallback(this.state.error);
+    }
+
+    return this.props.children;
+  }
+
+}

package/es/StringUtils.js

@@ -0,0 +1,290 @@
+/**
+ * check given string is empty.
+ * @param {string} string - The string to be check.
+ */
+export function isEmpty(string) {
+  if (!string) {
+    return true;
+  }
+
+  return string.length === 0;
+}
+/**
+ * check given string is not empty.
+ * @param {string} string - Th  e string to be check.
+ */
+
+export function isNotEmpty(string) {
+  return !isEmpty(string);
+}
+/**
+ * check given string is blank.
+ * @param {string} string - The string to be check.
+ */
+
+export function isBlank(string) {
+  if (!string) {
+    return true;
+  }
+
+  return !new RegExp('\\S', 'g').test(string);
+}
+/**
+ * check given string is not blank.
+ * @param {string} string - The string to be check.
+ */
+
+export function isNotBlank(string) {
+  return !isBlank(string);
+}
+/**
+ * find index of given char in the string.
+ * @param {string} string - The string to be modify.
+ */
+
+export function indexOf(string, chars, pos) {
+  if (string == null || typeof string === undefined) {
+    return -1;
+  }
+
+  if (pos) {
+    return str.indexOf(chars, typeof pos === undefined ? 0 : pos);
+  } else {
+    return str.indexOf(chars);
+  }
+}
+/**
+ * Capitalize the first letter of a string.
+ *
+ * @param {string} string - The input string to modify.
+ * @returns {string} The input string with the first letter capitalized.
+ */
+
+export function capitalizeFirstLetter(string) {
+  return !isStringEmpty(string) ? string.charAt(0).toUpperCase() + string.slice(1) : string;
+}
+/**
+ * Encode a string for HTML to prevent cross-site scripting (XSS) attacks.
+ *
+ * @param {string} str - The input string to encode for HTML.
+ * @returns {string} The encoded string safe for inclusion in HTML content.
+ */
+
+export function encodeForHtml(str) {
+  if (/<|>|&|"|'|\\/g.test(str) === true) {
+    str = str.replace(/&/g, '&amp;');
+    str = str.replace(/</g, '&lt;');
+    str = str.replace(/>/g, '&gt;');
+    str = str.replace(/"/g, '&quot;');
+    str = str.replace(/\\/g, '&#x5c;');
+    str = str.replace(/'/g, '&#39;');
+  }
+
+  return str;
+}
+/**
+ * Decode HTML entities in a string.
+ *
+ * @param {string} str - The input string containing HTML-encoded content.
+ * @returns {string} The decoded string.
+ */
+
+export function decodeContent(str) {
+  if (/&amp;|&lt;|&gt;|&quot;|&#x5c;|&#39;|&amp;lt;|&amp;gt;/g.test(str) == true) {
+    str = str.replace(/&amp;/g, '&');
+    str = str.replace(/&lt;|&amp;lt;/g, '<');
+    str = str.replace(/&gt;|&amp;gt;/g, '>');
+    str = str.replace(/&quot;/g, '"');
+    str = str.replace(/&#x5c;/g, '\\');
+    str = str.replace(/&#39;/g, "'");
+  }
+
+  return str;
+}
+/**
+ * Validatate email.
+ *
+ * @param {string} email - The input string to validate.
+ */
+
+export function validateEmail(email) {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+/**
+ * extract domain from the email.
+ *
+ * @param {string} email - The input email to extract domain.
+ */
+
+export function extractDomainFromEmail(email) {
+  const atIndex = email.lastIndexOf('@');
+  return atIndex !== -1 ? email.slice(atIndex + 1) : '';
+}
+/**
+ * Reverse a given string.
+ *
+ * @param {string} string - The input string to reverse.
+ * @returns {string} The reversed string.
+ */
+
+export function reverseString(string) {
+  return !isStringEmpty(string) ? string.split('').reverse().join('') : string;
+}
+/**
+ * Truncate a given string and append an ellipsis if it exceeds a specified length.
+ * @param {string} string - The string to truncate.
+ * @param {number} maxLength - The maximum length of the truncated string.
+ * @returns {string} The truncated string.
+ */
+
+export function truncate(string) {
+  let maxLength = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+
+  if (!isStringEmpty() && string.length > maxLength) {
+    return string.slice(0, maxLength) + '...';
+  }
+
+  return string;
+}
+/**
+ * Convert a string to PascalCase.
+ * Split the string into words, capitalize the first letter of each word, and join them 
+ * 
+ * @param {string} string - The input string to convert.
+ * @returns {string} The PascalCase version of the input string.
+ */
+
+export function toPascalCase(string) {
+  if (typeof string === 'string' && !isStringEmpty(string)) {
+    const pascalCaseStr = string.split(/[\s_-]+/).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join('');
+    return pascalCaseStr;
+  }
+}
+/**
+ * Convert a string to kebab-case.
+ * Replace spaces and underscores with hyphens, and convert to lowercase 
+ *
+ * @param {string} string - The input string to convert.
+ * @returns {string} The kebab-case version of the input string.
+ */
+
+export function toKebabCase(string) {
+  if (typeof string === 'string' && !isStringEmpty(string)) {
+    const kebabCaseStr = string.replace(/[\s_]+/g, '-').toLowerCase();
+    return kebabCaseStr;
+  }
+}
+/**
+ * Convert a string to snake_case.
+ * Replace spaces and hyphens with underscores, and convert to lowercase
+ *
+ * @param {string} string - The input string to convert.
+ * @returns {string} The snake_case version of the input string.
+ */
+
+export function toSnakeCase(string) {
+  if (typeof string === 'string' && !isStringEmpty(string)) {
+    const snakeCaseStr = string.replace(/[\s-]+/g, '_').toLowerCase();
+    return snakeCaseStr;
+  }
+}
+/**
+ * Join an array of strings into a single string using a specified delimiter.
+ *
+ * @param {string[]} array - The array of strings to join.
+ * @param {string} delimiter - The delimiter used to separate the strings in the output.
+ * @returns {string} The concatenated string with the specified delimiter.
+ */
+
+export function joinArray(array) {
+  let delimiter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ', ';
+
+  if (Array.isArray(array)) {
+    return array.join(delimiter);
+  }
+}
+/**
+ * Remove whitespace characters from a given string.
+ *
+ * @param {string} inputString - The input string from which to remove whitespace.
+ * @returns {string} The input string with whitespace characters removed.
+ */
+
+export function removeWhitespace(inputString) {
+  if (!isStringEmpty(inputString) && typeof inputString == 'string') {
+    return inputString.replace(/\s+/g, '');
+  }
+
+  return inputString;
+}
+/**
+ * Check if a given string is a palindrome.
+ *
+ * @param {string} string - The input string to check for palindromic property.
+ * @returns {boolean} True if the input string is a palindrome, false otherwise.
+ */
+
+export function isPalindrome(string) {
+  if (!isStringEmpty(string) && typeof string == 'string') {
+    const cleanString = string.toLowerCase().replace(/[^a-zA-Z0-9]/g, '');
+    const reversedString = cleanString.split('').reverse().join('');
+    return cleanString === reversedString;
+  }
+
+  return string;
+}
+/**
+ * Check if a string starts with a vowel (a, e, i, o, or u).
+ *
+ * @param {string} string - The input string to check.
+ * @returns {boolean} True if the string starts with a vowel, false otherwise.
+ */
+
+export function isStartsWithVowel(string) {
+  return /^[aeiouAEIOU]/.test(string);
+}
+;
+/**
+ * Count the number of occurrences of a substring in a string.
+ *
+ * @param {string} string - The input string to search in.
+ * @param {string} substring - The substring to count occurrences of.
+ * @returns {number} The number of occurrences of the substring in the input string.
+ */
+
+export function countOccurrences(string, substring) {
+  if (typeof string == 'string') {
+    const regex = new RegExp(substring, 'g');
+    const matches = string.match(regex);
+    return matches ? matches.length : 0;
+  }
+
+  return string;
+}
+/**
+ * Replace all occurrences of a substring with another substring in a string.
+ *
+ * @param {string} string - The input string in which to perform replacements.
+ * @param {string} target - The substring to find and replace.
+ * @param {string} replacement - The substring to replace occurrences of the target with.
+ * @returns {string} The input string with all occurrences of the target replaced.
+ */
+
+export function replaceAllOccurrences(string, target, replacement) {
+  if (!isStringEmpty(string) && typeof string == 'string') {
+    return string.split(target).join(replacement);
+  }
+
+  return string;
+}
+/**
+ * Encode a string to Base64.
+ *
+ * @param {string} inputString - The input string to encode.
+ * @returns {string} The Base64-encoded string.
+ */
+
+export function encodeToBase64(string) {
+  return btoa(string);
+}

package/es/abbreviateNumber.js

@@ -0,0 +1,44 @@
+/**
+ *
+ * @param {number|string} count
+ * @param {object} options
+ * @param {string} options.locale
+ * @param {boolean} options.withAbbr
+ * @param {number} options.decimals
+ * @returns
+ */
+export default function abbreviateNumber() {
+  let count = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  if (typeof count === 'string') {
+    count = parseInt(count);
+  }
+
+  if (global.Intl && global.Intl.NumberFormat) {
+    let numberFormat = Intl.NumberFormat(options.locale || 'en', {
+      notation: 'compact' // compactDisplay: "short",
+
+    });
+    return numberFormat.format(count);
+  } //Comaptibility
+
+
+  const COUNT_ABBRS = ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+  let {
+    withAbbr = true,
+    decimals = 2
+  } = options;
+  const i = 0 === count ? count : Math.floor(Math.log(count) / Math.log(1000));
+  let result = parseFloat((count / Math.pow(1000, i)).toFixed(decimals));
+
+  if (withAbbr) {
+    result += `${COUNT_ABBRS[i]}`;
+  }
+
+  return result;
+}
+/* need discussion 
+1001 => 1K+
+
+G, T, P, E, Z,Y are needed in practical */

package/es/accessKeyCodes.js

@@ -0,0 +1,18 @@
+export default {
+  tab: 9,
+  enter: 13,
+  space: 32,
+  rightArrow: 39,
+  leftArrow: 37,
+  topArrow: 38,
+  bottomArrow: 40
+};
+export const accessKeyNames = {
+  'tab': 'tab',
+  'enter': 'enter',
+  'space': 'space',
+  'arrowleft': 'arrowleft',
+  'arrowtop': 'arrowtop',
+  'arrowright': 'arrowright',
+  'arrowbottom': 'arrowbottom'
+};

package/es/applyOpenToCustomize.js

@@ -0,0 +1,29 @@
+/**
+ * Opening the customization, need to addd for behaviour changes. also add only enabled.
+ * @param {*} style 
+ * @param {*} options
+ * Example code
+ * <Component openToCutsomize={{prefix:'dot'}} />
+ * let style = applyOpenToCustomize(style,openToCutsomize)
+ */
+export default function applyOpenToCustomize(style, options) {
+  let resultStyle = style;
+
+  if (options && options.prefix) {
+    resultStyle = { ...style
+    };
+    let defaultPrefix = options.prefix || "";
+
+    if (defaultPrefix) {
+      defaultPrefix = `${defaultPrefix}-`;
+    }
+
+    Object.keys(style).forEach(styleName => {
+      if (resultStyle[styleName] && !resultStyle[styleName].includes(styleName)) {
+        resultStyle[styleName] = `${resultStyle[styleName]} ${defaultPrefix}${styleName}`;
+      }
+    });
+  }
+
+  return resultStyle;
+}

package/es/combineCustomStyle.js

@@ -0,0 +1,39 @@
+const REPLACER_SYMBOL = "$";
+/**
+ * 
+ * if two is same ==> do the think if replace do, if append do.
+ * replace vs append ==> append 
+ * append vs replace ==> replace  
+ * @param {*} style1
+ * @param {*} style2 
+ * @returns 
+ */
+
+export default function combineCustomStyle(style1, style2) {
+  let resultStyle = { ...style1
+  };
+  Object.keys(style2).forEach(styleName => {
+    let oldStyleName = style1[`$${styleName}`] ? `$${styleName}` : styleName;
+
+    if (oldStyleName.startsWith(REPLACER_SYMBOL) && styleName.startsWith(REPLACER_SYMBOL)) {
+      resultStyle[styleName] = style2[styleName];
+    } else if (!oldStyleName.startsWith(REPLACER_SYMBOL) && !styleName.startsWith(REPLACER_SYMBOL)) {
+      resultStyle[styleName] = `${resultStyle[styleName]} ${style2[styleName]}`;
+    } else {
+      delete resultStyle[oldStyleName];
+      resultStyle[styleName] = style2[styleName];
+    }
+    /*else if (oldStyleName.startsWith(REPLACER_SYMBOL) && !styleName.startsWith(REPLACER_SYMBOL)  ) {
+     
+      delete resultStyle[oldStyleName];
+      resultStyle[styleName] = style2[styleName];
+       }
+    else if (!oldStyleName.startsWith(REPLACER_SYMBOL) && styleName.startsWith(REPLACER_SYMBOL)  ) {
+      
+      delete resultStyle[oldStyleName];
+      resultStyle[styleName] = style2[styleName];
+     }*/
+
+  });
+  return resultStyle;
+}

package/es/compileClassNames.js

@@ -0,0 +1,29 @@
+import dataTypes, { isDataTypeOf } from "./dataTypes";
+import { hasOwnProperty } from "./objectUtils";
+
+const collectClassNames = function (processedClassNameList) {
+  for (let index = 0; index < (arguments.length <= 1 ? 0 : arguments.length - 1); index++) {
+    let classInfo = index + 1 < 1 || arguments.length <= index + 1 ? undefined : arguments[index + 1];
+
+    if (!classInfo) {
+      continue;
+    } else if (isDataTypeOf(classInfo, dataTypes.object)) {
+      for (let property in classInfo) {
+        if (hasOwnProperty.call(classInfo, property) && property !== 'undefined' && property !== 'null' && classInfo[property] && !processedClassNameList.includes(property)) {
+          processedClassNameList.push(property);
+        }
+      }
+    }
+  }
+};
+
+export default function compileClassNames() {
+  let resultClassNameList = [];
+
+  for (var _len = arguments.length, classinfoList = new Array(_len), _key = 0; _key < _len; _key++) {
+    classinfoList[_key] = arguments[_key];
+  }
+
+  collectClassNames(resultClassNameList, ...classinfoList);
+  return resultClassNameList.filter(a => a !== '').join(' ');
+}

package/es/constantProps/constant.js

@@ -0,0 +1,2 @@
+export const DUMMY_OBJECT = Object.freeze({});
+export const DUMMY_ARRAY = Object.freeze([]);

package/es/constantProps/index.js

@@ -0,0 +1 @@
+export * from "./uiProps";

package/es/constantProps/uiProps.js

@@ -0,0 +1,50 @@
+export const variantList = {
+  outlined: 'variant_outlined',
+  contained: 'variant_contained',
+  flushed: 'variant_flushed',
+  plain: 'variant_plain'
+};
+export const variants = Object.values(variantList);
+export const sizeList = {
+  xsmall: 'size_xsmall',
+  small: 'size_small',
+  medium: 'size_medium',
+  large: 'size_large',
+  xlarge: 'size_xlarge'
+};
+export const sizeKeys = Object.keys(sizeList);
+export const sizes = Object.values(sizeList);
+export const colorList = {
+  danger: 'color_danger',
+  success: 'color_success',
+  info: 'color_info',
+  primary: 'color_primary',
+  secondary: 'color_secondary',
+  warning: 'color_warning'
+};
+export const colorKeys = Object.keys(colorList);
+export const colors = Object.values(colorList);
+export const shapeList = {
+  circle: 'shape_circle',
+  oval: 'shape_oval',
+  square: 'shape_square',
+  roundedRect: 'shape_roundedRect',
+  rounded: 'shape_rounded'
+};
+export const shapes = Object.values(shapeList);
+export const decorationList = {
+  overLine: 'decoration_overline',
+  lineThrough: 'decoration_linethrough',
+  underLine: 'decoration_underline',
+  none: 'decoration_none'
+};
+export const decorations = Object.values(decorationList);
+export const positionList = {
+  left: 'position_left',
+  right: 'position_right',
+  top: 'position_top',
+  bottom: 'position_bottom',
+  center: 'position_center'
+};
+export const positionKeys = Object.keys(positionList);
+export const positions = Object.values(positionList);

package/es/contextFactory.js

@@ -0,0 +1,15 @@
+import { createContext } from 'react';
+const context = {};
+/**
+ * 
+ * @param {string} name 
+ * @returns {object}
+ */
+
+export default function contextFactory(name) {
+  if (!context[name]) {
+    context[name] = /*#__PURE__*/createContext();
+  }
+
+  return context[name];
+}

package/es/createTemplateLiteral.js

@@ -0,0 +1,77 @@
+export default function createTemplateLiteral(templateStrings) {
+  for (var _len = arguments.length, expressionKeys = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    expressionKeys[_key - 1] = arguments[_key];
+  }
+
+  return function () {
+    for (var _len2 = arguments.length, expressionValues = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      expressionValues[_key2] = arguments[_key2];
+    }
+
+    let resultString = [templateStrings[0]];
+    expressionKeys.forEach(function (expressionKey, i) {
+      let expressionValue = expressionValues[i];
+      let nextTemplateString = templateStrings[i + 1];
+
+      if (expressionValue === null || expressionValue === undefined || expressionValue === "") {
+        nextTemplateString = nextTemplateString.replace(/^_/, '');
+      }
+
+      resultString.push(expressionValue, nextTemplateString);
+    });
+    let resultStr = resultString.join('');
+    resultStr = resultStr.replace(/_$/, '');
+    return resultStr;
+  };
+}
+/* refer the doc https://developers.google.com/web/updates/2015/01/ES6-Template-Strings
+
+UnderSatnd the terms - String interpolation, Embedded expressions
+
+Go through the topic https://developers.google.com/web/updates/2015/01/ES6-Template-Strings#tagged_templates
+
+Things to note fn`Hello ${you}! You're looking ${adjective} today!` desugars to fn(["Hello ", "! You're looking ", " today!"], you, adjective);
+
+Please go through the example code
+
+Our implementation constructCustomMessage is the handler for the tagged template function. 
+It receives the static words and its substitutions as seen above as the arguments.
+
+It returns a function that receives the values for the substitutions. Upon passing the values for the inner function
+it executes the algorithm as mentioned in the doc to construct the final message.
+"The (n + 1)th argument corresponds to the substitution that takes place between the nth and (n + 1)th entries in the string array"
+
+
+function constructCustomMessage(staticWordsList, ...embeddedExpressionKeyList)
+{
+    return (...valuesForEmbeddedExpressionList)=>{
+
+        let finalMessage = staticWordsList[0];
+        embeddedExpressionKeyList.forEach(function(expressionKey, index) {
+            let expressionValue = valuesForEmbeddedExpressionList[index];
+            let nextStaticWord = staticWordsList[index+1];
+            if(expressionValue===null || expressionValue === undefined || expressionValue === ""){
+               // Replace the underscore '_' present at the beginning of string with empty value.  
+                    nextStaticWord = nextStaticWord.replace(/^_/, '');
+            }
+             finalMessage += expressionValue + nextStaticWord;
+
+        });
+          // Replace the underscore '_' present at the end of string with empty value.  
+         finalMessage = finalMessage.replace(/_$/,'');
+        return finalMessage ;
+    };
+
+}
+*/
+
+/*
+Sample Invocation Format
+
+var username;
+var tag;
+var handlerFunctiontoFormMessage = constructCustomMessage`<b>${username} says</b>: "${tag}"`;
+var outputString = handlerFunctiontoFormMessage('Mani Venkat', '& is a fun tag');
+console.log(outputString);
+
+*/