@zohodesk/utils 1.0.0-temp-1

package/es/crud/ArrayManager.js

@@ -0,0 +1,63 @@
+import { appendToArray, deleteFromArrayOfObjectById, deleteFromArrayByItem, modifyArrayOfObjectItemById, modifyArrayItemByItem, emptyArray } from '@zohodesk/utils/es/arrayCRUD';
+import { DUMMY_ARRAY } from '../../../dotkit/src/utils/constants';
+
+class ArrayManager {
+  constructor() {
+    let initialArray = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DUMMY_ARRAY;
+    this.array = initialArray;
+  }
+
+  addItem(item) {
+    this.array = appendToArray({
+      array: this.array,
+      item
+    });
+    return this.array;
+  }
+
+  removeItemById(id) {
+    this.array = deleteFromArrayOfObjectById({
+      arrayOfObject: this.array,
+      id
+    });
+    return this.array;
+  }
+
+  removeItemByItem(item) {
+    this.array = deleteFromArrayByItem({
+      array: this.array,
+      item
+    });
+    return this.array;
+  }
+
+  clearItems() {
+    this.array = emptyArray();
+    return this.array;
+  }
+
+  updateItemById(id, newItem) {
+    this.array = modifyArrayOfObjectItemById({
+      arrayOfObject: this.array,
+      id,
+      newItem
+    });
+    return this.array;
+  }
+
+  updateItemByItem(currentItem, newItem) {
+    this.array = modifyArrayItemByItem({
+      array: this.array,
+      currentItem,
+      newItem
+    });
+    return this.array;
+  }
+
+  getArray() {
+    return this.array;
+  }
+
+}
+
+export default ArrayManager;

package/es/crud/ObjectManager.js

@@ -0,0 +1,54 @@
+import { emptyObject, mergeObjects, updateValueByKey as _updateObjectValueByKey, removeValueByKey as _removeObjectByKey, removeValueByKeys as _removeObjectByKeys } from '@zohodesk/utils/es/objectCRUD';
+import { DUMMY_OBJECT } from '../../../dotkit/src/utils/constants';
+
+class ObjectManager {
+  constructor() {
+    let initialObject = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DUMMY_OBJECT;
+    this.object = initialObject;
+  }
+
+  setValue(newObject) {
+    this.object = mergeObjects({
+      object: this.object,
+      newObject
+    });
+    return this.object;
+  }
+
+  clearValue() {
+    this.object = emptyObject();
+    return this.object;
+  }
+
+  updateValueByKey(key, value) {
+    this.object = _updateObjectValueByKey({
+      object: this.object,
+      key,
+      value
+    });
+    return this.object;
+  }
+
+  removeValueByKeys(keys) {
+    this.object = _removeObjectByKeys({
+      object: this.object,
+      keys
+    });
+    return this.object;
+  }
+
+  removeValueByKey(key) {
+    this.object = _removeObjectByKey({
+      object: this.object,
+      key
+    });
+    return this.object;
+  }
+
+  getValue() {
+    return this.object;
+  }
+
+}
+
+export default ObjectManager;

package/es/crud/arrayCRUD.js

@@ -0,0 +1,76 @@
+import { DUMMY_ARRAY } from "../constantProps/constant";
+import { deepEqual } from "../deepEqual";
+export const appendToArray = _ref => {
+  let {
+    array,
+    item
+  } = _ref;
+  return [...array, item];
+};
+export const modifyArrayOfObjectItemById = _ref2 => {
+  let {
+    arrayOfObject,
+    id,
+    newItem
+  } = _ref2;
+  let found = false;
+  return arrayOfObject.map(object => {
+    if (!found && id !== undefined && object.id === id) {
+      found = true;
+      return Array.isArray(newItem) ? [...newItem] : typeof newItem === 'object' ? { ...object,
+        ...newItem
+      } : newItem;
+    }
+
+    return object;
+  });
+};
+export const modifyArrayItemByItem = _ref3 => {
+  let {
+    array,
+    currentItem,
+    newItem
+  } = _ref3;
+  let found = false;
+  return array.map(arrayItem => {
+    if (!found && currentItem !== undefined && deepEqual(arrayItem, currentItem)) {
+      found = true;
+      return newItem;
+    }
+
+    return arrayItem;
+  });
+};
+export const deleteFromArrayOfObjectById = _ref4 => {
+  let {
+    arrayOfObject,
+    id
+  } = _ref4;
+  let found = false;
+  return arrayOfObject.filter(object => {
+    if (!found && id !== undefined && object.id === id) {
+      found = true;
+      return false;
+    }
+
+    return true;
+  });
+};
+export const deleteFromArrayByItem = _ref5 => {
+  let {
+    array,
+    currentItem
+  } = _ref5;
+  let found = false;
+  return array.filter(arrayItem => {
+    if (!found && currentItem !== undefined && deepEqual(arrayItem, currentItem)) {
+      found = true;
+      return false;
+    }
+
+    return true;
+  });
+};
+export const emptyArray = () => {
+  return DUMMY_ARRAY;
+};

package/es/crud/objectCRUD.js

@@ -0,0 +1,49 @@
+import { DUMMY_OBJECT } from "../constantProps/constant";
+export const mergeObjects = _ref => {
+  let {
+    object,
+    newObject
+  } = _ref;
+  return { ...object,
+    ...newObject
+  };
+};
+export const emptyObject = () => {
+  return DUMMY_OBJECT;
+};
+export const updateObjectValueByKey = _ref2 => {
+  let {
+    object,
+    key,
+    value
+  } = _ref2;
+  return { ...object,
+    [key]: value
+  };
+};
+export const removeObjectByKeys = _ref3 => {
+  let {
+    object,
+    keys
+  } = _ref3;
+  const newObject = { ...object
+  };
+
+  if (Array.isArray(keys)) {
+    keys.forEach(key => {
+      delete newObject[key];
+    });
+  }
+
+  return newObject;
+};
+export const removeObjectByKey = _ref4 => {
+  let {
+    object,
+    key
+  } = _ref4;
+  const newObject = { ...object
+  };
+  delete newObject[key];
+  return newObject;
+};

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);
+  };
+}

package/es/deepEqual.js

@@ -0,0 +1,26 @@
+export const deepEqual = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+
+  if (typeof a === 'object' && typeof b === 'object' && a !== null && b !== null) {
+    if (Array.isArray(a) !== Array.isArray(b)) {
+      return false;
+    }
+
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+
+    if (keysA.length !== keysB.length) {
+      return false;
+    }
+
+    return keysA.every(key => deepEqual(a[key], b[key]));
+  }
+
+  if (typeof a === 'function' && typeof b === 'function') {
+    return a.toString().replace(/\s+/g, '') === b.toString().replace(/\s+/g, '');
+  }
+
+  return false;
+};

package/es/disCustomStyleProps.js

@@ -0,0 +1,45 @@
+// import PropTypes from "prop-types";
+// import mergeStyle from "./mergeStyle";
+// import { Button } from "../../base/src/Button/index";
+// export default (props)=>{
+//     let { customStyle,  openCustomStyle}  = props;
+//     return {
+//         customStyle,
+//         openDefaultToCustomize
+//     };
+// }
+// if two is same ==> do the think replace with last , append at end 
+// replace vs append ==> append 
+// append vs replace ==> replace 
+// DotButton.js
+// DotButton.module.css 
+// function DotButton({ customStyle }){
+//     dotButdefault => customStyle : {
+//         base : DotButton.style.pols 
+//     }
+//     props => customStyle {
+//         base :  
+//     }
+//     return <Button customStyle={}></Button>
+// }
+// Button => set of compoents 
+// DotButton => set of comepons
+// function creatButtonWithIcon({Button,Icon}){
+//     return (props)=>{
+//         customStyle={}
+//         return <Button customStyle={ssss}>
+//                 <Icon></Icon>   
+//         </Button>
+//     }
+// }
+// Button1.js
+// Icon1.js
+// creatButtonWithIcon({
+//     Button : Button1,
+//     Icon : Icon1
+// });
+// Button1custome(props){
+//     props.customStyle 
+//     combineCustomStyle()
+//     return Button 
+// }

package/es/getCompliedClassName.js

@@ -0,0 +1,12 @@
+import compileClassNames from "./compileClassNames";
+export default (function (customClassName) {
+  let isPlainClassName = typeof customClassName === "string" ? true : false;
+
+  for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    props[_key - 1] = arguments[_key];
+  }
+
+  return compileClassNames(...props, {
+    [customClassName]: !!isPlainClassName
+  });
+});

package/es/getCompliedCustomId.js

@@ -0,0 +1,16 @@
+export default (function (_ref, defaultCustomId) {
+  let {
+    customId,
+    customIdPrefix = "",
+    customIdSuffix = ""
+  } = _ref;
+  let otherCustomOption = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  let returnId = customId;
+
+  if (typeof defaultCustomId === "function") {
+    let options = ['', customIdPrefix, customIdSuffix, ...otherCustomOption];
+    returnId = defaultCustomId.apply(null, options); //returnId = defaultCustomId`${customIdPrefix} ${customIdSuffix}`;
+  }
+
+  return returnId ? returnId.toLowerCase() : null;
+});

package/es/getCurrentTime.js

@@ -0,0 +1,10 @@
+export default function getCurrentTime() {
+  const now = new Date();
+  const hours = now.getHours();
+  const minutes = now.getMinutes().toString().padStart(2, '0');
+  const seconds = now.getSeconds().toString().padStart(2, '0');
+  const ampm = hours >= 12 ? 'PM' : 'AM';
+  const formattedHours = hours % 12 || 12; // Convert 24-hour time to 12-hour format
+
+  return `${formattedHours}:${minutes}:${seconds} ${ampm}`;
+}

package/es/getCustomBoundingClientRect.js

@@ -0,0 +1,11 @@
+export default function getCustomBoundingClientRect(element) {
+  const elementRect = element.getBoundingClientRect();
+  return {
+    height: elementRect.height,
+    width: elementRect.width,
+    top: elementRect.top,
+    left: elementRect.left,
+    right: document.documentElement.clientWidth - elementRect.right,
+    bottom: document.documentElement.clientHeight - elementRect.bottom
+  };
+}

package/es/index.js

@@ -0,0 +1,11 @@
+export { default as debounce } from './debounce';
+export { default as uniqueNumber } from './uniqueNumber';
+export { default as omit } from './omit';
+export { default as mergeStyle } from './mergeStyle';
+export { default as applyOpenToCustomize } from './applyOpenToCustomize';
+export { default as combineCustomStyle } from './combineCustomStyle';
+export { default as compileClassNames } from './compileClassNames';
+export { default as ErrorBoundary } from './ErrorBoundary';
+export { default as loadResource } from './loadResource';
+export { default as accessKeyCodes, accessKeyNames } from "./accessKeyCodes";
+export { default as renderNode, isRenderable } from './renderNode';

package/es/isTouchDevice.js

@@ -0,0 +1,9 @@
+export default function isTouchDevice() {
+  if ('ontouchstart' in window || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0) {
+    /* browser with either Touch Events of Pointer Events
+      running on touch-capable device */
+    return true;
+  }
+
+  return false;
+}

package/es/jsonToQueryString.js

@@ -0,0 +1,6 @@
+export default function jsonToQueryString(json) {
+  var str = Object.keys(json).map(function (key) {
+    return encodeURIComponent(key) + '=' + encodeURIComponent(json[key]);
+  }).join('&');
+  return str != '' ? '?' + str : str;
+}

package/es/loadResource.js

@@ -0,0 +1,56 @@
+/* eslint-disable import/prefer-default-export */
+
+/* use promise and remove callback */
+export default function loadResource(url, type, id, callback) {
+  let needDefer = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+  return new Promise(resolve => {
+    let css;
+    let script;
+
+    if (id && document.getElementById(id)) {
+      resolve();
+      return;
+    }
+
+    if (type === 'css') {
+      css = document.createElement('link');
+      css.type = 'text/css';
+      css.rel = 'stylesheet';
+      css.href = url;
+      css.id = id || '';
+
+      css.onload = function () {
+        resolve();
+      };
+
+      css.onerror = function () {
+        resolve();
+      };
+
+      document.getElementsByTagName('head')[0].appendChild(css);
+    } else if (type === 'js') {
+      script = document.createElement('script');
+      script.type = 'text/javascript';
+      script.src = url;
+      script.defer = needDefer;
+
+      script.onload = function () {
+        resolve();
+
+        if (id) {
+          script.id = id;
+        }
+
+        if (typeof callback === 'function') {
+          callback();
+        }
+      };
+
+      script.onerror = function () {
+        resolve();
+      };
+
+      document.getElementsByTagName('head')[0].appendChild(script);
+    }
+  });
+}

package/es/mergeStyle.js

@@ -0,0 +1,53 @@
+const REPLACER_SYMBOL = '$'; // $ startWith is used for replace the existing style.
+// all other will be append
+
+export default function mergeStyle(defaultStyle) {
+  let customStyle = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let additionalStyle = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  // if(!Object.keys(defaultStyle).includes('base')) {
+  //   throw new Error(`STYLE CUSTOMIZATION RULE - Your style sheet should have "base" class name for customization`);
+  // }
+  return Object.keys(customStyle).reduce((res, next) => {
+    if (next.startsWith(REPLACER_SYMBOL)) {
+      let styleValue = customStyle[next];
+      let styleName = next.replace(REPLACER_SYMBOL, '');
+
+      if (!res[styleName] && !additionalStyle.includes(styleName)) {
+        throw new Error(`UNKNOWN CLASSNAME DETECTED - Given customStyle's key "${styleName}" is not available in that component style`);
+      } else if (additionalStyle.includes(styleName)) {
+        res[styleName] = styleValue;
+      } else {
+        let val = res[styleName];
+        Object.keys(res).map(keyName => {
+          let styleKey = res[keyName];
+          let ind = styleKey.indexOf(val);
+
+          if (ind !== -1) {
+            res[keyName] = styleKey.replace(val, styleValue);
+          }
+        });
+      }
+    } else if (res[next]) {
+      let val = res[next];
+      Object.keys(res).map(keyName => {
+        let styleKey = res[keyName];
+        let styleClasses = styleKey.split(' ');
+        val = val.split(' ')[0];
+        let ind = styleClasses.indexOf(val);
+
+        if (ind !== -1) {
+          styleClasses[ind] = styleClasses[ind] + ' ' + customStyle[next];
+          res[keyName] = styleClasses.join(' ');
+        }
+      });
+    } else if (additionalStyle.includes(next)) {
+      res[next] = customStyle[next];
+    } else if (!res[next] && !additionalStyle.includes(next)) {
+      // res[next] = customStyle[next];
+      throw new Error(`UNKNOWN CLASSNAME DETECTED - Given customStyle's key "${next}" is not available in that component style`);
+    }
+
+    return res;
+  }, { ...defaultStyle
+  });
+}

package/es/objectUtils.js

@@ -0,0 +1,4 @@
+export const hasOwnProperty = Object.hasOwnProperty;
+export const isToStringReferenceEqual = data => {
+  return data.toString === Object.prototype.toString;
+};

package/es/omit.js

@@ -0,0 +1,11 @@
+export default (keys => {
+  return function omit(obj) {
+    return Object.keys(obj).reduce((res, next) => {
+      if (!keys.includes(next)) {
+        res[next] = obj[next];
+      }
+
+      return res;
+    }, {});
+  };
+});

package/es/props/automationProps.js

@@ -0,0 +1,7 @@
+import PropTypes from 'prop-types';
+export const automationPropsName = 'customId';
+export default {
+  customId: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),
+  customIdPrefix: PropTypes.string,
+  customIdSuffix: PropTypes.string
+};

package/es/props/customReducerPropTypes.js

@@ -0,0 +1,5 @@
+import PropTypes from 'prop-types';
+export default {
+  customReducer: PropTypes.func
+};
+export const customReducer = 'customReducer';

package/es/props/customStyleProps.js

@@ -0,0 +1,9 @@
+import PropTypes from 'prop-types';
+export default {
+  customStyle: PropTypes.object
+};
+/**
+ * Prop Name
+ */
+
+export const customStyle = "customStyle";

package/es/props/generalAriaProps.js

@@ -0,0 +1,6 @@
+import PropTypes from 'prop-types';
+export default {
+  'aria-label': PropTypes.string,
+  'aria-labelledby': PropTypes.string,
+  tabIndex: PropTypes.oneOfType([PropTypes.string, PropTypes.number])
+};

package/es/props/tagAttributeProps.js

@@ -0,0 +1,35 @@
+import PropTypes from 'prop-types';
+/**
+ * tagAttributes - is used to spread these attributes for events customize and override few attributes.
+ */
+
+export const tagAttributes = "tagAttributes";
+const attributesList = ["tabIndex"];
+const dataAttribute = "^data|on";
+export const tagAttributesPropType = function (props, propName, componentName) {
+  if (Object.prototype.toString.call(props) !== "[object Object]") {
+    console.error(`Warning: Failed prop type: Invalid prop \`${propName}\` of type \`${props ? typeof props : undefined}\` supplied to \`${componentName}\`, expected \`object\`.`);
+  }
+
+  let curPattern = new RegExp(`^(${attributesList.join("|")})$`);
+  let curPattern2 = new RegExp(dataAttribute);
+  Object.keys(props[propName]).forEach(keyName => {
+    if (!(curPattern.test(keyName) || curPattern2.test(keyName))) {
+      console.warn(`Warning: these attributes ( ${keyName} ) aren't mentioned in ${propName}, component: ${componentName}`);
+    }
+  });
+};
+export const tagAttributesShape = shapeOf => (props, propName, componentName) => {
+  let propObject = props[propName];
+  propObject && Object.keys(propObject).forEach(keyName => {
+    if (!shapeOf.hasOwnProperty(keyName)) {
+      console.error(`Warning: these key ( ${keyName} ) aren't allowed in ${propName}, component: ${componentName}`);
+      return;
+    }
+
+    shapeOf[keyName](propObject, keyName, `${componentName} prop: ${propName}.${keyName} `);
+  });
+};
+export default {
+  [tagAttributes]: tagAttributesPropType
+};

package/es/props/tagGeneralAttributeProps.js

@@ -0,0 +1,35 @@
+import PropTypes from 'prop-types';
+/**
+ * tagGeneralAttributes - is to spread the global attributes in component.
+ */
+
+export const tagGeneralAttributes = "tagGeneralAttributes";
+const attributesList = ["accesskey", "contentEditable", "dir", "draggable", "hidden", "lang", "tabIndex", "title", "spellcheck", "translate"];
+const dataAttribute = "^data|on";
+export const tagGeneralAttributesPropType = function (props, propName, componentName) {
+  if (Object.prototype.toString.call(props) !== "[object Object]") {
+    console.error(`Warning: Failed prop type: Invalid prop \`${propName}\` of type \`${props ? typeof props : undefined}\` supplied to \`${componentName}\`, expected \`object\`.`);
+  }
+
+  let curPattern = new RegExp(`^(${attributesList.join("|")})$`);
+  let curPattern2 = new RegExp(dataAttribute);
+  Object.keys(props[propName]).forEach(keyName => {
+    if (!(curPattern.test(keyName) || curPattern2.test(keyName))) {
+      console.warn(`Warning: these attributes ( ${keyName} ) aren't mentioned in tagGeneralAttributes, component: ${componentName}`);
+    }
+  });
+};
+export const tagGeneralAttributesShape = shapeOf => (props, propName, componentName) => {
+  let propObject = props[propName];
+  propObject && Object.keys(propObject).forEach(keyName => {
+    if (!shapeOf.hasOwnProperty(keyName)) {
+      console.error(`Warning: these key ( ${keyName} ) aren't allowed in ${propName}, component: ${componentName}`);
+      return;
+    }
+
+    shapeOf[keyName](propObject, keyName, `${componentName} prop: ${propName}.${keyName} `);
+  });
+};
+export default {
+  [tagGeneralAttributes]: tagGeneralAttributesPropType
+};