@zohodesk/components 1.0.0-temp-164 → 1.0.0-temp-165

package/es/DateTime/dateFormatUtils/monthChange.js

@@ -23,6 +23,7 @@ export function getChangedMonth(values, event, focusOrders, keyActions) {
     startPoint,
     endPoint
   } = getMonthDetails();
+
   if (keyCode === 38) {
     //up arrow
     if (newMonth === endPoint || !newMonth) {
@@ -45,15 +46,19 @@ export function getChangedMonth(values, event, focusOrders, keyActions) {
     const keyString = String.fromCharCode(which);
     let newValue = isNewType ? keyString : month.toString() + keyString;
     newValue = Number.parseInt(newValue);
+
     if (isNewType) {
       isChanged = true;
+
       if (newValue * 10 > endPoint) {
         newFocusOrder += 1;
       }
+
       newMonth = newValue;
     } else {
       isChanged = true;
       newFocusOrder += 1;
+
       if (newValue > endPoint) {
         newMonth = endPoint;
       } else if (!newValue) {
@@ -66,12 +71,15 @@ export function getChangedMonth(values, event, focusOrders, keyActions) {
     isChanged = true;
     newMonth = '';
   }
+
   const dayEnd = getDayEnd(newMonth, newYear);
   let dayChanged = false;
+
   if (newDay && newDay > dayEnd) {
     dayChanged = true;
     newDay = dayEnd;
   }
+
   return {
     day: dayChanged ? newDay : day,
     month: newMonth,

package/es/DateTime/dateFormatUtils/timeChange.js

@@ -23,6 +23,7 @@ export function getChangedHour(values, event, focusOrders, keyActions) {
     startPoint,
     endPoint
   } = getHourDetails(is24Hour);
+
   if (keyCode === 38) {
     //up arrow
     if (newHour === endPoint || getIsEmptyHour(newHour, is24Hour)) {
@@ -45,15 +46,19 @@ export function getChangedHour(values, event, focusOrders, keyActions) {
     const keyString = String.fromCharCode(which);
     let newValue = isNewType ? keyString : hour.toString() + keyString;
     newValue = Number.parseInt(newValue);
+
     if (isNewType) {
       isChanged = true;
+
       if (newValue * 10 > endPoint) {
         newFocusOrder += 1;
       }
+
       newHour = newValue;
     } else {
       isChanged = true;
       newFocusOrder += 1;
+
       if (newValue > endPoint) {
         newHour = endPoint;
       } else if (!newValue) {
@@ -66,6 +71,7 @@ export function getChangedHour(values, event, focusOrders, keyActions) {
     isChanged = true;
     newHour = '';
   }
+
   return {
     hour: newHour,
     isChanged,
@@ -92,6 +98,7 @@ export function getChangedMinute(values, event, focusOrders, keyActions) {
     startPoint,
     endPoint
   } = getMinuteDetails();
+
   if (keyCode === 38) {
     //up arrow
     if (newMinute === endPoint || isEmptyMinute) {
@@ -114,15 +121,19 @@ export function getChangedMinute(values, event, focusOrders, keyActions) {
     const keyString = String.fromCharCode(which);
     let newValue = isNewType ? keyString : minute.toString() + keyString;
     newValue = Number.parseInt(newValue);
+
     if (isNewType) {
       isChanged = true;
+
       if (newValue * 10 > endPoint) {
         newFocusOrder += 1;
       }
+
       newMinute = newValue;
     } else {
       isChanged = true;
       newFocusOrder += 1;
+
       if (newValue > endPoint) {
         newMinute = endPoint;
       } else {
@@ -133,13 +144,16 @@ export function getChangedMinute(values, event, focusOrders, keyActions) {
     isChanged = true;
     newMinute = '';
   }
+
   return {
     minute: newMinute,
     isChanged,
     focusOrder: newFocusOrder
   };
 }
-export function getChangedNoon(values, event, focusOrders /*keyActions*/) {
+export function getChangedNoon(values, event, focusOrders
+/*keyActions*/
+) {
   const {
     keyCode,
     which
@@ -152,9 +166,7 @@ export function getChangedNoon(values, event, focusOrders /*keyActions*/) {
   const {
     focusOrder
   } = focusOrders;
-  const newFocusOrder = focusOrder;
-
-  // const isNewType = getIsNewValueType(focusOrders, keyActions);
+  const newFocusOrder = focusOrder; // const isNewType = getIsNewValueType(focusOrders, keyActions);
 
   const {
     allowedValues
@@ -162,6 +174,7 @@ export function getChangedNoon(values, event, focusOrders /*keyActions*/) {
   const [startPoint] = allowedValues;
   const endPoint = allowedValues[allowedValues.length - 1];
   const currentNoonIndex = allowedValues.indexOf(newNoon);
+
   if (keyCode === 38) {
     //up arrow
     if (newNoon === endPoint || !newNoon) {
@@ -181,11 +194,11 @@ export function getChangedNoon(values, event, focusOrders /*keyActions*/) {
       newNoon = allowedValues[currentNoonIndex - 1];
     }
   } else if (getIsNoonValueTyped(event)) {
-    const keyString = String.fromCharCode(which);
+    const keyString = String.fromCharCode(which); // let newValue = isNewType ? keyString : noon.toString() + keyString;
 
-    // let newValue = isNewType ? keyString : noon.toString() + keyString;
     const newValue = keyString;
     const needChangeNoon = newNoon.indexOf(newValue) === -1 ? true : false;
+
     if (needChangeNoon) {
       let newValueIndex = currentNoonIndex;
       allowedValues.some((val, index) => {
@@ -193,8 +206,10 @@ export function getChangedNoon(values, event, focusOrders /*keyActions*/) {
           newValueIndex = index;
           return true;
         }
+
         return false;
       });
+
       if (currentNoonIndex !== newValueIndex) {
         isChanged = true;
         newNoon = allowedValues[newValueIndex];
@@ -204,6 +219,7 @@ export function getChangedNoon(values, event, focusOrders /*keyActions*/) {
     isChanged = true;
     newNoon = '';
   }
+
   return {
     noon: newNoon,
     isChanged,

package/es/DateTime/dateFormatUtils/yearChange.js

@@ -15,16 +15,17 @@ export function getChangedYear(values, event, focusOrders, keyActions, _ref) {
     day = '',
     month = ''
   } = values;
-  let isChanged = false;
+  let isChanged = false; //Year Two Digit case
 
-  //Year Two Digit case
   const {
     length: yearLength
   } = yearInfo;
   const oldYear = year; // For get Centuries
+
   if (yearLength === 2) {
     year = convertYearToTwoDigit(year).toString();
   }
+
   let newDay = Number.parseInt(day) || 0;
   const newMonth = Number.parseInt(month) || 0;
   let newYear = Number.parseInt(year) || 0;
@@ -38,6 +39,7 @@ export function getChangedYear(values, event, focusOrders, keyActions, _ref) {
     endPoint,
     currentYear
   } = getYearDetails(yearLength);
+
   if (keyCode === 38) {
     //up arrow
     if (newYear === endPoint) {
@@ -67,14 +69,17 @@ export function getChangedYear(values, event, focusOrders, keyActions, _ref) {
     let newValue = isNewType ? keyString : year.toString() + keyString;
     const newValueString = newValue || '';
     newValue = Number.parseInt(newValue);
+
     if (isNewType) {
       isChanged = true;
       newYear = newValue;
     } else {
       isChanged = true;
+
       if (newValue * 10 > endPoint) {
         newFocusOrder += 1;
       }
+
       if (newValue > endPoint) {
         // newYear = endPoint;
         newYear = currentYear;
@@ -93,15 +98,19 @@ export function getChangedYear(values, event, focusOrders, keyActions, _ref) {
     isChanged = true;
     newYear = '';
   }
+
   if (yearLength === 2) {
     newYear = convertTwoDigitToYear(newYear, oldYear);
   }
+
   const dayEnd = getDayEnd(newMonth, newYear);
   let dayChanged = false;
+
   if (newDay && newDay > dayEnd) {
     dayChanged = true;
     newDay = dayEnd;
   }
+
   return {
     day: dayChanged ? newDay : day,
     year: newYear,

package/es/DateTime/objectUtils.js

@@ -4,56 +4,50 @@ export const clone = (a, b, c, d, e, f) => {
 };
 export const extract = (obj, keys, target) => {
   target = target || {};
+
   for (var i in obj) {
     if (keys.indexOf(i) < 0) continue;
     if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
     target[i] = obj[i];
   }
+
   return target;
 };
 export const omit = (obj, keys, target) => {
   target = target || {};
+
   for (var i in obj) {
     if (keys.indexOf(i) >= 0) continue;
     if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
     target[i] = obj[i];
   }
+
   return target;
 };
 export const equals = (x, y) => {
-  if (x === y) return true;
-  // if both x and y are null or undefined and exactly the same
+  if (x === y) return true; // if both x and y are null or undefined and exactly the same
 
-  if (x == null && y != null || x != null && y == null) return false;
-  //break if not same null or undefined
+  if (x == null && y != null || x != null && y == null) return false; //break if not same null or undefined
 
-  if (!(x instanceof Object) || !(y instanceof Object)) return false;
-  // if they are not strictly equal, they both need to be Objects
+  if (!(x instanceof Object) || !(y instanceof Object)) return false; // if they are not strictly equal, they both need to be Objects
 
-  if (x.constructor !== y.constructor) return false;
-  // they must have the exact same prototype chain, the closest we can do is
+  if (x.constructor !== y.constructor) return false; // they must have the exact same prototype chain, the closest we can do is
   // test there constructor.
 
   for (var p in x) {
-    if (!x.hasOwnProperty(p)) continue;
-    // other properties were tested using x.constructor === y.constructor
+    if (!x.hasOwnProperty(p)) continue; // other properties were tested using x.constructor === y.constructor
 
-    if (!y.hasOwnProperty(p)) return false;
-    // allows to compare x[ p ] and y[ p ] when set to undefined
+    if (!y.hasOwnProperty(p)) return false; // allows to compare x[ p ] and y[ p ] when set to undefined
 
-    if (x[p] === y[p]) continue;
-    // if they have the same strict value or identity then they are equal
+    if (x[p] === y[p]) continue; // if they have the same strict value or identity then they are equal
 
-    if (typeof x[p] !== 'object') return false;
-    // Numbers, Strings, Functions, Booleans must be strictly equal
+    if (typeof x[p] !== 'object') return false; // Numbers, Strings, Functions, Booleans must be strictly equal
 
-    if (!equals(x[p], y[p])) return false;
-    // Objects and Arrays must be tested recursively
+    if (!equals(x[p], y[p])) return false; // Objects and Arrays must be tested recursively
   }
 
   for (p in y) {
-    if (y.hasOwnProperty(p) && !x.hasOwnProperty(p)) return false;
-    // allows x[ p ] to be set to undefined
+    if (y.hasOwnProperty(p) && !x.hasOwnProperty(p)) return false; // allows x[ p ] to be set to undefined
   }
 
   return true;

package/es/DateTime/props/defaultProps.js

@@ -19,7 +19,8 @@ export const DateTime_defaultProps = {
   isPadding: false,
   i18nKeys: {},
   is24Hour: false,
-  isDefaultPosition: false
+  isDefaultPosition: false,
+  customDateFormat: null
 };
 export const DateWidget_defaultProps = {
   borderColor: 'default',

package/es/DateTime/typeChecker.js

@@ -1,8 +1,10 @@
 const exports = {};
 let types = 'Array Object String Date RegExp Function Boolean Number Null Undefined'.split(' ');
+
 let type = function () {
   return Object.prototype.toString.call(this).slice(8, -1);
 };
+
 for (let i = types.length; i--;) {
   /*eslint-disable */
   exports['is' + types[i]] = function (self) {
@@ -13,4 +15,5 @@ for (let i = types.length; i--;) {
 }
 /*eslint-enable */
 
+
 export default exports;

package/es/DateTime/validator.js

@@ -11,17 +11,21 @@ const validator = {
     let newValidationRules = validationRules ? validationRules : {};
     let checkPropsRules = defaultCheckPropsRules;
     let checkPropsOrder = [];
+
     for (let i = 0; i < checkPropsRules.length; i++) {
       let prop = checkPropsRules[i];
+
       if (Object.prototype.hasOwnProperty.call(currentProps, prop)) {
         if (newValidationRulesOrder.indexOf(prop) === -1) {
           checkPropsOrder.push(prop);
         }
+
         if (!Object.prototype.hasOwnProperty.call(newValidationRules, prop)) {
           newValidationRules[prop] = currentProps[prop];
         }
       }
     }
+
     newValidationRulesOrder = !Object.prototype.hasOwnProperty.call(newValidation, 'rulesOrder') ? checkPropsOrder.concat(newValidationRulesOrder) : validationRulesOrder;
     let isRulesFound = Object.keys(newValidationRules).length;
     newValidationRules = isRulesFound ? validator.composeRulesForValidation(newType, defaultValidateRules, newValidationRules) : newValidationRules;
@@ -47,22 +51,28 @@ const validator = {
       onFailValidation
     } = validationObj;
     let skipIfEmptyField = null;
+
     if (validationRules.required === false && (fieldType !== 'radio' || fieldType !== 'checkbox')) {
       skipIfEmptyField = val => {
         if (fieldType === 'onegroup' || fieldType === 'multigroup') {
           return !val || !(val.length > 0);
         }
+
         let value = (val || '').trim();
         return value.length < 1;
       };
     }
+
     if (skipIfEmptyField === null || skipIfEmptyField(text) === false) {
       for (let i = 0, len = validationRulesOrder.length; i < len; i++) {
         let rule = validationRulesOrder[i];
+
         if (!validationRules[rule] || !typeChecker.isFunction(validationRules[rule])) {
           continue;
         }
+
         let isInValid = validationRules[rule](text, inputTag);
+
         if (isInValid) {
           let message = validationMessages[rule] && typeChecker.isFunction(validationMessages[rule]) ? validationMessages[rule](text, inputTag) : validationMessages[rule];
           onFailValidation && onFailValidation(rule, message, inputTag);
@@ -70,52 +80,66 @@ const validator = {
         }
       }
     }
+
     onPassValidation && onPassValidation(text, inputTag);
   },
   composeRulesForValidation: (type, defaultValidateRules, newValidationRules) => {
     let defaultPatterns = validator.regexs;
+
     for (let i = 0, len = defaultValidateRules.length; i < len; i++) {
       let rule = defaultValidateRules[i];
       let ruleInfo = newValidationRules[rule] || '';
+
       if (ruleInfo && !typeChecker.isFunction(ruleInfo)) {
         if (rule === 'required' && ruleInfo === true) {
           newValidationRules[rule] = (val, el) => {
             if (el.willValidate && el.validity.valueMissing) {
               return true;
             }
+
             if (type === 'radio' || type === 'checkbox') {
               return el.checked === false;
             }
+
             if (type === 'onegroup' || type === 'multigroup') {
               return !val || val.length < 1;
             }
+
             let value = (val || '').replace(/\s{2,}/g, ' ').trim();
             return value.length < 1;
           };
         } else if (rule === 'maxLength' && !Number.isNaN(ruleInfo) && Number.isFinite(ruleInfo)) {
           let maxLength = Number(ruleInfo);
+
           newValidationRules[rule] = (val, el) => {
             if (el.willValidate && el.validity.tooLong) {
               return true;
             }
+
             let value = val || '';
+
             if (type !== 'multigroup') {
               value = val.trim();
             }
+
             return !(value.length <= maxLength);
           };
         } else if (rule === 'minLength' && !Number.isNaN(ruleInfo) && Number.isFinite(ruleInfo)) {
           let minLength = Number(ruleInfo);
+
           newValidationRules[rule] = val => {
             let value = val || '';
+
             if (type !== 'multigroup') {
               value = val.trim();
             }
+
             return !(value.length >= minLength);
           };
         } else if (rule === 'rangeLength' && /^([-+\d]+)*([,]{1,1}([-+\d]+))$/.test(ruleInfo) === true) {
           let rangeLength = ruleInfo;
           rangeLength = rangeLength.split(',').map(a => Number(a));
+
           newValidationRules[rule] = val => {
             let value = (val || '').trim();
             return !(value.length >= rangeLength[0] && value.length <= rangeLength[1]);
@@ -123,119 +147,146 @@ const validator = {
         } else if (rule === 'step' && ruleInfo) {
           let step = Number(ruleInfo);
           let stepTypes = ['number', 'range', 'date', 'datetime', 'datetime-local', 'month', 'time', 'week'];
+
           newValidationRules[rule] = (val, el) => {
             if (stepTypes.indexOf(type) !== -1) {
               if (el.willValidate && el.validity.stepMismatch) {
                 return true;
               }
+
               return false;
             }
+
             let value = (val || '').trim();
             value = Number(value);
+
             if (Number.isNaN(value) || !Number.isFinite(value) || Number.isNaN(step) || !Number.isFinite(step)) {
               return true;
             }
+
             return !(value % step === 0);
           };
         } else if (rule === 'max') {
           let max = Number(ruleInfo);
           let maxTypes = ['number', 'range', 'date', 'datetime', 'datetime-local', 'month', 'time', 'week'];
+
           newValidationRules[rule] = (val, el) => {
             if (maxTypes.indexOf(type) !== -1) {
               if (el.willValidate && el.validity.rangeOverflow) {
                 return true;
               }
+
               return false;
             }
+
             let value = (val || '').trim();
             value = Number(value);
+
             if (Number.isNaN(value) || !Number.isFinite(value) || Number.isNaN(max) || !Number.isFinite(max)) {
               return true;
             }
+
             return !(value <= max);
           };
         } else if (rule === 'min') {
           let min = Number(ruleInfo);
           let minTypes = ['number', 'range', 'date', 'datetime', 'datetime-local', 'month', 'time', 'week'];
+
           newValidationRules[rule] = (val, el) => {
             if (minTypes.indexOf(type) !== -1) {
               if (el.willValidate && el.validity.rangeUnderflow) {
                 return true;
               }
+
               return false;
             }
+
             let value = (val || '').trim();
             value = Number(value);
+
             if (Number.isNaN(value) || !Number.isFinite(value) || Number.isNaN(min) || !Number.isFinite(min)) {
               return true;
             }
+
             return !(value >= min);
           };
         } else if (rule === 'range' && /^([-+\d]+)*([,]{1,1}([-+\d]+))$/.test(ruleInfo) === true) {
           let ranges;
           ranges = ranges.split(',').map(a => Number(a));
+
           newValidationRules[rule] = val => {
             let value = (val || '').trim();
             value = Number(value);
+
             if (Number.isNaN(value) || !Number.isFinite(value)) {
               return true;
             }
+
             return !(value >= ranges[0] && value <= ranges[1]);
           };
         } else if ((rule === 'digits' || rule === 'integer' || rule === 'double') && ruleInfo === true) {
           newValidationRules[rule] = val => {
             let value = (val || '').trim();
             value = Number(value);
+
             if (Number.isNaN(value) || !Number.isFinite(value)) {
               return true;
             }
+
             let condition = true;
+
             if (rule === 'integer') {
               condition = Number.isSafeInteger(value);
             }
+
             if (rule === 'double') {
               condition = -Number.MAX_VALUE <= value && Number.MAX_VALUE >= value;
             }
+
             return !defaultPatterns[rule].test(value) && condition;
           };
         } else if ((rule === 'timezonedate' || rule === 'datetimezone' || rule === 'date' || rule === 'datetime') && ruleInfo === true) {
           newValidationRules[rule] = val => {
             let value = (val || '').trim();
+
             if (!defaultPatterns[rule].test(value)) {
               return true;
             }
+
             if (rule === 'datetime') {
               let index = 0;
-              value = value.split('T')[index];
-              //let timings = value[1].replace("Z","").split(":")
+              value = value.split('T')[index]; //let timings = value[1].replace("Z","").split(":")
               //let
               //if( !defaultPatterns[rule].test(value); )
             }
 
             value = value.replace('/', '-');
             value = value.replace(':', '-');
-            let values = value.split('-');
+            let values = value.split('-'); // Extract the string into month, date and year
 
-            // Extract the string into month, date and year
             let yy = parseInt(values[0]);
             let mm = parseInt(values[1]);
-            let dd = parseInt(values[2]);
+            let dd = parseInt(values[2]); // Create list of days of a month [assume there is no leap year by default]
 
-            // Create list of days of a month [assume there is no leap year by default]
             let ListofDays = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
             if (mm === 1 || mm > 2) {
               if (dd > ListofDays[mm - 1]) {
                 return true;
               }
             }
+
             if (mm === 2) {
               let lyear = false;
+
               if (!(yy % 4) && yy % 100 || !(yy % 400)) {
                 lyear = true;
               }
+
               if (lyear === false && dd >= 29) {
                 return true;
               }
+
               if (lyear === true && dd > 29) {
                 return true;
               }
@@ -254,6 +305,7 @@ const validator = {
         }
       }
     }
+
     return newValidationRules;
   },
   regexs: {

package/es/DropBox/DropBox.js

@@ -1,4 +1,5 @@
 function _extends() { _extends = Object.assign ? Object.assign.bind() : 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); }
+
 import React, { useRef, Fragment, useContext } from 'react';
 import FocusScope from '@zohodesk/a11y/es/FocusScope/FocusScope';
 import Modal from '../Modal/Modal';
@@ -8,7 +9,7 @@ import cssJSLogic from './css/cssJSLogic';
 import DropBoxElement from './DropBoxElement/DropBoxElement';
 import { DropBoxDefaultProps } from './props/defaultProps';
 import { DropBoxPropTypes } from './props/propTypes';
-import { cancelBubblingEffect } from './../utils/Common';
+import { stopPropagation } from './../utils/Common';
 import style from './css/DropBox.module.css';
 export default function DropBox(props) {
   const focusRef = useRef(null);
@@ -26,14 +27,17 @@ export default function DropBox(props) {
     direction
   } = DropBoxContext || {};
   let windowWidth,
-    mobileWidth = getLibraryConfig('mobileWidth'),
-    isModel = false;
+      mobileWidth = getLibraryConfig('mobileWidth'),
+      isModel = false;
+
   if (needResponsive) {
     windowWidth = window.innerWidth;
+
     if (windowWidth <= mobileWidth) {
       isModel = true;
     }
   }
+
   const {
     zIndexStyle
   } = cssJSLogic(props);
@@ -62,13 +66,13 @@ export default function DropBox(props) {
   }, /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
     className: `${style.freezeLayer} ${style.freeze}`,
     style: zIndexStyle,
-    onClick: cancelBubblingEffect
+    onClick: stopPropagation
   }), dropBoxEle)) : !isAbsolutePositioningNeeded && isActive ? /*#__PURE__*/React.createElement(Modal, {
     portalId: portalId
   }, /*#__PURE__*/React.createElement(React.Fragment, null, isRestrictScroll ? /*#__PURE__*/React.createElement("div", {
     className: style.freezeLayer,
     style: zIndexStyle,
-    onClick: cancelBubblingEffect
+    onClick: stopPropagation
   }) : null, dropBoxEle)) : dropBoxEle;
 }
 DropBox.propTypes = DropBoxPropTypes;