@zohodesk/utils 1.0.1-alpha.2057

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015-present Lerna Contributors
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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/__tests__/abbreviateNumber.spec.js

@@ -0,0 +1,70 @@
+import abbreviateNumber from '../abbreviateNumber';
+describe("abbreviateNumber", () => {
+  test("value should be zero string and input also string", () => {
+    let a = abbreviateNumber("0");
+    expect(a).toBe("0");
+  });
+  test("value should be zero string", () => {
+    let a = abbreviateNumber(0);
+    expect(a).toBe("0");
+  });
+  test("value should be 1K string", () => {
+    let a = abbreviateNumber(1000);
+    expect(a).toBe("1K");
+  });
+  test("value should be 1K string", () => {
+    let a = abbreviateNumber(1001);
+    expect(a).toBe("1K");
+  });
+  test("value should be 1K+ string", () => {
+    let a = abbreviateNumber(1001);
+    expect(a).toBe("1K");
+  });
+  test("value should be 1M string", () => {
+    let a = abbreviateNumber(1000000);
+    expect(a).toBe("1M");
+  });
+  test("value should be 1M+ string", () => {
+    let a = abbreviateNumber(1000001);
+    expect(a).toBe("1M");
+  });
+});
+describe("abbreviateNumber without browser Intl", () => {
+  beforeAll(() => {
+    global.Intl = null;
+  });
+  test("value should be zero string and input also string", () => {
+    let a = abbreviateNumber("0");
+    expect(a).toBe("0");
+  });
+  test("value should be zero string", () => {
+    let a = abbreviateNumber(0);
+    expect(a).toBe("0");
+  });
+  test("value should be zero string", () => {
+    let a = abbreviateNumber(0, {
+      withAbbr: false
+    });
+    expect(a).toBe("0");
+  });
+  test("value should be 1K string", () => {
+    let a = abbreviateNumber(1000);
+    expect(a).toBe("1K");
+  });
+  test("value should be 1K string", () => {
+    let a = abbreviateNumber(1001);
+    expect(a).toBe("1K");
+  });
+  test("value should be 1K+ string", () => {
+    let a = abbreviateNumber(1001);
+    expect(a).toBe("1K");
+  });
+  test("value should be 1M string", () => {
+    let a = abbreviateNumber(1000000);
+    expect(a).toBe("1M");
+  });
+  test("value should be 1M+ string", () => {
+    let a = abbreviateNumber(1000001);
+    expect(a).toBe("1M");
+  });
+});

package/es/__tests__/compileClassNames.spec.js

@@ -0,0 +1,48 @@
+import compileClassNames from '../compileClassNames';
+describe("compileClassNames", () => {
+  test("should be class1", () => {
+    let output = compileClassNames({
+      "class1": true
+    });
+    expect(output).toBe("class1");
+  });
+  test("should be class1 class2", () => {
+    let output = compileClassNames({
+      "class1": true,
+      "class2": true
+    });
+    expect(output).toBe("class1 class2");
+  });
+  test("should be  class2", () => {
+    let output = compileClassNames({
+      "class1": false,
+      "class2": true
+    });
+    expect(output).toBe("class2");
+  });
+  test("should be  empty", () => {
+    let output = compileClassNames({
+      "class1": false,
+      "class2": false
+    });
+    expect(output).toBe("");
+  });
+  test("should be empty input is empty object ", () => {
+    let output = compileClassNames({});
+    expect(output).toBe("");
+  });
+  test("should be class1 multiple argument and first argument with null ", () => {
+    let output = compileClassNames(null, {
+      class1: true
+    });
+    expect(output).toBe("class1");
+  });
+  test("should be  multiple argument and first argument with null second arg as string ", () => {
+    let output = compileClassNames(null, "class1");
+    expect(output).toBe("class1");
+  });
+  test("should be empty input is empty object ", () => {
+    let output = compileClassNames(["class1"]);
+    expect(output).toBe("class1");
+  });
+});

package/es/__tests__/contextFactory.spec.js

@@ -0,0 +1,12 @@
+import contextFactory from '../contextFactory';
+describe("contextFactory", () => {
+  test("create new context", () => {
+    let RouterContext = contextFactory("router");
+    expect(RouterContext.$$typeof).toBe(Symbol.for('react.context'));
+  });
+  test("if context exist return same context", () => {
+    let RouterContext1 = contextFactory("router");
+    let RouterContext2 = contextFactory("router");
+    expect(RouterContext1).toBe(RouterContext2);
+  });
+});

package/es/__tests__/createTemplateLiteral.spec.js

@@ -0,0 +1,4 @@
+import createTemplateLiteral from '../createTemplateLiteral';
+describe("createTemplateLiteral", () => {
+  test("", () => {});
+});

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,31 @@
+import "core-js/modules/es.array.includes";
+
+/**
+ * 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,151 @@
+import dataTypes, { isDataTypeOf } from "./dataTypes";
+import { hasOwnProperty, isToStringReferenceEqual } from "./objectUtils";
+/**
+ *  
+ * @param  {object} classinfoList 
+ * @returns {string}
+ */
+
+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;
+    }
+
+    if (isDataTypeOf(classInfo, dataTypes.string) || isDataTypeOf(classInfo, dataTypes.number)) {
+      processedClassNameList.push(classInfo);
+    } else if (isDataTypeOf(classInfo, dataTypes.array)) {
+      processedClassNameList.push(collectClassNames.apply(null, classInfo));
+    } else if (isDataTypeOf(classInfo, dataTypes.object)) {
+      for (let property in classInfo) {
+        if (hasOwnProperty.call(classInfo, property) && classInfo[property]) {
+          processedClassNameList.push(property === "undefined" ? '' : 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.join(' ');
+}
+;
+/* discussion
+passing object is enough i think. remaining option needed!!!
+*/
+//18-Nov-2021 code review changes updated.
+
+/*
+>>>>>>>>>>Code Review Suggestion Starts >>>>>>
+let hasOwn = {}.hasOwnProperty;
+
+Accounting readability, please change this to Object.hasOwnProperty
+
+---
+const compileClassNames = (...props)=>{
+Please check the alternate term - collate -> collateClassNames -> Collect and Combine the classnames.
+---
+
+for (let i = 0; i < props.length; i++) {
+
+    Please try to to stick with functional programming. Again for the readability perspective.
+    Also, please stick with naming conventions for variables (i -> index).
+
+---
+if (argType === 'string' || argType === 'number') {
+          classes.push(this && this[arg] || arg);
+      } else if (Array.isArray(arg)) {
+          classes.push(compileClassNames.apply(this, arg));
+      } else if (argType === 'object') {
+          if (arg.toString === Object.prototype.toString) {
+              for (let key in arg) {
+                  if (hasOwn.call(arg, key) && arg[key]) {
+                      classes.push(this && this[key] || key);
+                  }
+              }
+          } else {
+              classes.push(arg.toString());
+          }
+      }
+    }
+In this code block, pushing up the array,object checks before string || number will be easy to follow up as it clarifies about the reursive call, its context.
+Please check the possibility of avoiding the usage of 'this' statement due to its complexity in understanding the concept.
+
+---
+Please write a functional method for the below line for easier understanding 
+  
+if (arg.toString === Object.prototype.toString) {
+
+---
+
+Adding dedicated method to get the datatype of variables will help to stick on the SRP.
+---
+Check the possibility of providing platform to extend the algorithm works for other data structures like Map, WeakMap,etc..
+
+>>>>>>> Code Review Suggestion Ends >>>>>>>>>>>>>>>>
+*/
+
+/*
+
+>>>>>> Alternative Implementation Starts >>>>>>>>>>>>>>>> 
+
+let boundHasOwnMethod = Object.hasOwnProperty;
+
+ const collateClassNames = (...classinfoList) =>{
+     let processedClassNameList = [];
+     classinfoList.forEach( ( classInfo,index )=>{
+         if(!classInfo)
+         {
+            // continue the next iteration
+             return;
+         }
+         let dataTypeofClassInfo = getDataType(classInfo);
+         if (dataTypeofClassInfo === 'string' || dataTypeofClassInfo === 'number')
+         {
+             processedClassNameList.push(classInfo);
+         }
+         else if(dataTypeofClassInfo === 'array')
+         {
+             processedClassNameList.push(collateClassNames(...classInfo));
+         }
+         else if(dataTypeofClassInfo === 'object')
+         {
+             for (let property in classInfo) {
+                  if (boundHasOwnMethod.call(classInfo,property ) && classInfo[property]) {
+                      processedClassNameList.push(property);
+                  }
+              }
+         }
+        
+
+     });
+     const joinClassNames = processedClassNameList.join(' ');
+    return joinClassNames;
+
+ }
+
+ const getDataType = (data)=>{
+    let dataTypeofClassInfo = typeof data;
+    let isArrayDataType = Array.isArray(data) === true;
+    if(isArrayDataType)
+    {
+        return 'array';
+    }
+    else 
+    {
+        return dataTypeofClassInfo;
+    }
+   
+ };
+
+>>>>>>>>>>>>>>>> Alternative Implementation Ends>>>>>>>>>>>>>> 
+*/

package/es/constantProps/index.js

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

package/es/constantProps/uiProps.js

@@ -0,0 +1,34 @@
+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);

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);
+
+*/

package/es/dataTypes.js

@@ -0,0 +1,25 @@
+const dataTypes = {
+  "number": "number",
+  "array": "array",
+  "string": "string",
+  "object": "object",
+  "bigint": "bigint",
+  "symbol": "symbol",
+  "undefined": "undefined",
+  "function": "function",
+  "boolean": "boolean"
+};
+export const getDataType = data => {
+  let typeofData = typeof data;
+  let isArrayDataType = Array.isArray(data);
+
+  if (isArrayDataType) {
+    return dataTypes.array;
+  } else {
+    return dataTypes[typeofData];
+  }
+};
+export const isDataTypeOf = (data, type) => {
+  return getDataType(data) === type;
+};
+export default dataTypes;

package/es/debounce.js

@@ -0,0 +1,12 @@
+export default function debounce(fn, delay) {
+  let handle = null;
+  return function () {
+    if (handle) {
+      handle = clearTimeout(handle);
+    }
+
+    handle = setTimeout(() => {
+      fn(...arguments);
+    }, delay);
+  };
+}