@zohodesk/library-platform 1.1.9 → 1.1.10

package/es/library/behaviours/field-validation/frameworks/utils/__tests__/formValidate.test.js

@@ -0,0 +1,284 @@
+// import { fieldValidate, validator } from '../../utils/fieldValidate';
+import { fieldValidate } from "../formValidate";
+describe('fieldValidate', () => {
+  test('Validate empty string', () => {
+    const fieldDetails = {
+      type: 'Text',
+      isMandatory: true
+    };
+    const result = fieldValidate('', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate non-empty string', () => {
+    const fieldDetails = {
+      type: 'Text',
+      isMandatory: true
+    };
+    const result = fieldValidate('test', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate empty array', () => {
+    const fieldDetails = {
+      type: 'Multiselect',
+      isMandatory: true
+    };
+    const result = fieldValidate([], fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate non-empty array', () => {
+    const fieldDetails = {
+      type: 'Multiselect',
+      isMandatory: true
+    };
+    const result = fieldValidate(['item'], fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate empty object', () => {
+    const fieldDetails = {
+      type: 'Object',
+      isMandatory: true
+    };
+    const result = fieldValidate({}, fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate non-empty object', () => {
+    const fieldDetails = {
+      type: 'Object',
+      isMandatory: true
+    };
+    const result = fieldValidate({
+      key: 'value'
+    }, fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate valid email', () => {
+    const fieldDetails = {
+      type: 'Email'
+    };
+    const result = fieldValidate('test@example.com', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate invalid email', () => {
+    const fieldDetails = {
+      type: 'Email'
+    };
+    const result = fieldValidate('invalid-email', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.valid.check');
+  });
+  test('Validate valid phone number', () => {
+    const fieldDetails = {
+      type: 'Phone'
+    };
+    const result = fieldValidate('+1234567890', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate invalid phone number', () => {
+    const fieldDetails = {
+      type: 'Phone'
+    };
+    const result = fieldValidate('***-***-****', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.valid.check');
+  });
+  test('Validate valid integer', () => {
+    const fieldDetails = {
+      type: 'Number'
+    };
+    const result = fieldValidate(123, fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate invalid integer', () => {
+    const fieldDetails = {
+      type: 'Number'
+    };
+    const result = fieldValidate('123.45', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.valid.check');
+  });
+  test('Validate valid decimal', () => {
+    const fieldDetails = {
+      type: 'Decimal',
+      decimalPlaces: 2
+    }; // NOTE: as per formValidate.js, the decimalPlaces is must for Decimal Field
+
+    const result = fieldValidate(123.45, fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate invalid decimal', () => {
+    const fieldDetails = {
+      type: 'Decimal'
+    };
+    const result = fieldValidate('invalid-decimal', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.valid.check');
+  });
+  test('Validate valid date', () => {
+    const fieldDetails = {
+      type: 'Date'
+    };
+    const result = fieldValidate('2025-02-11T00:00:00Z', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test.skip('Validate invalid date', () => {
+    const fieldDetails = {
+      type: 'Date'
+    };
+    const result = fieldValidate('invalid-date', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.valid.check');
+  });
+  test('Validate mandatory field', () => {
+    const fieldDetails = {
+      type: 'Text',
+      isMandatory: true
+    };
+    const result = fieldValidate('', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate field with max length', () => {
+    const fieldDetails = {
+      type: 'Text',
+      maxLength: 3
+    };
+    const result = fieldValidate('test', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('support.form.more.than.max.length');
+  });
+  test('Validate field with valid length', () => {
+    const fieldDetails = {
+      type: 'Text',
+      maxLength: 5
+    };
+    const result = fieldValidate('test', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate valid decimal places', () => {
+    const fieldDetails = {
+      type: 'Decimal',
+      decimalPlaces: 2
+    };
+    const result = fieldValidate(123.45, fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate invalid decimal places', () => {
+    const fieldDetails = {
+      type: 'Decimal',
+      decimalPlaces: 2
+    };
+    const result = fieldValidate(123.456, fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('support.form.decimal.places.length.error.message');
+  });
+  test('Validate empty multi-select', () => {
+    const fieldDetails = {
+      type: 'Multiselect',
+      isMandatory: true
+    };
+    const result = fieldValidate([], fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate non-empty multi-select', () => {
+    const fieldDetails = {
+      type: 'Multiselect',
+      isMandatory: true
+    };
+    const result = fieldValidate(['item'], fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate empty multi-select with -None- value', () => {
+    const fieldDetails = {
+      type: 'Multiselect',
+      isMandatory: true
+    };
+    const result = fieldValidate(['-None-'], fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate non-empty multi-select with -None- value', () => {
+    const fieldDetails = {
+      type: 'Multiselect',
+      isMandatory: true
+    };
+    const result = fieldValidate(['item', '-None-'], fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate empty picklist', () => {
+    const fieldDetails = {
+      type: 'Picklist',
+      isMandatory: true
+    };
+    const result = fieldValidate('', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate non-empty picklist', () => {
+    const fieldDetails = {
+      type: 'Picklist',
+      isMandatory: true
+    };
+    const result = fieldValidate('item', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate empty picklist with -None- value', () => {
+    const fieldDetails = {
+      type: 'Picklist',
+      isMandatory: true
+    };
+    const result = fieldValidate('-None-', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate non-empty picklist with -None- value', () => {
+    const fieldDetails = {
+      type: 'Picklist',
+      isMandatory: true
+    };
+    const result = fieldValidate('item', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate empty boolean field', () => {
+    const fieldDetails = {
+      type: 'Boolean',
+      isMandatory: true
+    };
+    const result = fieldValidate(false, fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate valid website', () => {
+    const fieldDetails = {
+      type: 'URL'
+    };
+    const result = fieldValidate('htt' + 'p://example.com', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test.skip('Validate invalid website', () => {
+    const fieldDetails = {
+      type: 'URL'
+    };
+    const result = fieldValidate('invalid-url', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.valid.check');
+  });
+  test('Validate valid URL', () => {
+    const fieldDetails = {
+      type: 'URL'
+    };
+    const result = fieldValidate('htt' + 'p://example.com', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test.skip('Validate invalid URL', () => {
+    const fieldDetails = {
+      type: 'URL'
+    };
+    const result = fieldValidate('invalid-url', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.valid.check');
+  });
+});

package/es/library/behaviours/field-validation/frameworks/utils/formValidate.js

@@ -0,0 +1,334 @@
+/** Libraries * */
+// import { i18NProviderUtils } from '@zohodesk/i18n';
+const i18NProviderUtils = {
+  getI18NValue(key, values) {
+    return key;
+  }
+
+};
+/** Methods * */
+
+const formatWebsiteUrl = url => {
+  const whitelistedDomains = ['htt' + 'p://', 'htt' + 'ps://', 'ftp://', 'simplehelp://', 'dynamicsnav://'];
+  const site = url.toLowerCase();
+  const isValidWebsite = whitelistedDomains.some(domain => site.startsWith(domain));
+
+  if (!isValidWebsite) {
+    return `htt${''}p://${url}`;
+  }
+
+  return url;
+};
+
+function getNoneText() {
+  const valueNoneText = '-None-';
+  return {
+    valueNoneText
+  };
+} // let ticketFieldTypes = [
+//   'LookUp String',
+//   'Picklist String',
+//   'Multiselect Array',
+//   'Email String',
+//   'Text String',
+//   'Textarea String',
+//   'Date String',
+//   'DateTime String',
+//   'Boolean boolean',
+//   'URL String',
+//   'Phone phone',
+//   'Number Number',
+//   'Percent String',
+//   'Decimal String',
+//   'Currency String'
+// ];
+
+
+export const validator = {
+  isEmpty(value) {
+    const valueType = typeof value;
+
+    if (valueType === 'string') {
+      return this.isEmptyString(value);
+    }
+
+    if (Array.isArray(value)) {
+      return this.isEmptyArr(value);
+    }
+
+    if (valueType === 'object') {
+      return this.isEmptyObj(value);
+    }
+
+    if (valueType === 'boolean' || value) {
+      return false;
+    }
+
+    return true;
+  },
+
+  isEmptyString(value) {
+    if (value && typeof value === 'string' && value.trim()) {
+      return false;
+    }
+
+    return true;
+  },
+
+  isEmptyArr(value) {
+    if (Array.isArray(value) && value.length > 0) {
+      return false;
+    }
+
+    return true;
+  },
+
+  isEmptyMultiSelect(value) {
+    if (!this.isEmpty(value) && !(value.length <= 2 && value.every(val => this.isNoneValue(val)))) {
+      return false;
+    }
+
+    return true;
+  },
+
+  isEmptyPicklist(value) {
+    if (!this.isEmpty(value) && !this.isNoneValue(value)) {
+      return false;
+    }
+
+    return true;
+  },
+
+  isEmptyObj(value) {
+    for (const key in value) {
+      if (value.hasOwnProperty(key)) {
+        return false;
+      }
+    }
+
+    return true;
+  },
+
+  isValidLength(value, length) {
+    let type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'max';
+    const valueType = typeof value;
+    const inpVal = valueType === 'number' ? value.toString() : value;
+    const valueLength = (inpVal || '').length;
+
+    if (valueType === 'string' || valueType === 'number' || Array.isArray(value)) {
+      if (type === 'max' && valueLength > length) {
+        return true;
+      }
+
+      if (type === 'min' && valueLength < length) {
+        return true;
+      }
+
+      return false;
+    }
+
+    return false;
+  },
+
+  isMaxLength(value, argum) {
+    return this.isValidLength(value, argum, 'max');
+  },
+
+  isMinLength(value, argum) {
+    return this.isValidLength(value, argum, 'min');
+  },
+
+  isValidInteger(value) {
+    const valueType = typeof value;
+    const inpVal = valueType === 'number' ? value.toString() : value;
+
+    if (inpVal) {
+      const re = /(^-?\d\d*$)/;
+
+      if (isNaN(inpVal) || inpVal.indexOf('.') !== -1 || !re.test(inpVal)) {
+        return false;
+      }
+
+      return true;
+    }
+
+    return false;
+  },
+
+  isValidDecimal(value) {
+    const valueType = typeof value;
+    const inpVal = valueType === 'number' ? value.toString() : value;
+    const restr = '^-?[0-9]\\d*(|\\.\\d[0-9]*)$';
+    const re = new RegExp(restr);
+
+    if (re.test(inpVal)) {
+      return true;
+    }
+
+    return false;
+  },
+
+  isValidDecimalPlaces(value, decimalPlaces) {
+    const valueType = typeof value;
+    const inpVal = valueType === 'number' ? value.toString() : value;
+    const restr = `^-?\\d*(|\\.\\d[0-9]{0,${decimalPlaces - 1}})$`;
+    const re = new RegExp(restr);
+
+    if (re.test(inpVal)) {
+      return true;
+    }
+
+    return false;
+  },
+
+  isValidPhone(value) {
+    // old validation
+    const phoneRegEx = /^[0-9a-zA-Z_()\+\-\.\$@\?\,\:\'\/\!\s]+/;
+    const match = value.match(phoneRegEx);
+
+    if (!match || value !== match[0]) {
+      return false;
+    }
+
+    return true; // let valueType = typeof value;
+    // let inpVal = valueType === 'number' ? value.toString() : value;
+    // let re = new RegExp(/^\+?\d+(-\d+)*$/);
+    // if (re.test(inpVal)) {
+    //   return true;
+    // }
+    // return false;
+  },
+
+  isValidEmail(value, isReplyValidation) {
+    const re = isReplyValidation ? /^[\wÀ-ž\+\#]([\wÀ-ž\-\.\+\'\&\/\#\~]*)@([\wÀ-ž\-\.]*)(\.[a-zA-ZÀ-ž]{2,22}(\.[a-zA-ZÀ-ž]{2}){0,2})$/ : /^[\wÀ-ž]([\wÀ-ž\-\.\+\'\&\/]*)@([\wÀ-ž\-\.]*)(\.[a-zA-ZÀ-ž]{2,22}(\.[a-zA-ZÀ-ž]{2}){0,2})$/; // swedish character support
+    // let re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+
+    if (re.test(value)) {
+      return true;
+    }
+
+    return false;
+  },
+
+  isValidWebsite(value) {
+    const newValue = formatWebsiteUrl(value);
+    const re = /^(ht|f)tp(s?):\/\/[-.\w]*(\/?)([a-zA-Z0-9\-\.\?,:'\/\\\+=&amp;%\$#_@]*)?$/;
+
+    if (re.test(newValue)) {
+      return true;
+    }
+
+    return false;
+  },
+
+  isValidDate(dateObj) {
+    if (dateObj || dateObj instanceof Date && dateObj.getFullYear() > 1000) {
+      return true;
+    }
+
+    return false;
+  },
+
+  isReminder(value) {
+    const alerTypes = value.alertTypes || [];
+    return !!alerTypes.length;
+  },
+
+  isNoneValue() {
+    let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    const inpVal = value.trim && value.trim();
+    const {
+      valueNoneText: noneText
+    } = getNoneText();
+    const i18nNoneValue = i18NProviderUtils.getI18NValue('-None-');
+
+    if (typeof inpVal === 'string' && (inpVal === noneText || inpVal === i18nNoneValue)) {
+      return true;
+    }
+
+    return false;
+  },
+
+  isValidDuration() {
+    let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const {
+      hoursSpent,
+      minutesSpent
+    } = value;
+
+    if (hoursSpent < 24 && minutesSpent < 60) {
+      return true;
+    }
+
+    return false;
+  }
+
+};
+export function fieldValidate(value, fieldDetails) {
+  const patternMapping = {
+    LookUp: '',
+    Email: 'isValidEmail',
+    Number: 'isValidInteger',
+    Text: '',
+    // No Check
+    Picklist: '',
+    // No Check
+    Textarea: '',
+    // No Check
+    DateTime: 'isValidDate',
+    // valid date check or valid dateTime check
+    Currency: 'isValidDecimal',
+    // check only decimal & decimal places, server side convert rouding option
+    Decimal: 'isValidDecimal',
+    Percent: 'isValidDecimal',
+    Boolean: '',
+    // No Check
+    Phone: 'isValidPhone',
+    // URL: 'isValidWebsite',// remove for validation
+    Date: 'isValidDate',
+    Radio: '',
+    // No Check
+    Duration: '',
+    // No Check
+    Multiselect: '' // No Check
+
+  };
+  const emptyValidateMapping = {
+    Multiselect: 'isEmptyMultiSelect',
+    Picklist: 'isEmptyPicklist'
+  };
+  const {
+    isMandatory,
+    i18NLabel,
+    type: fieldType,
+    maxLength,
+    decimalPlaces,
+    apiName: fieldName,
+    localizedValue = ''
+  } = fieldDetails;
+  const fieldLabel = localizedValue || i18NLabel;
+  const validationMethod = patternMapping[fieldType];
+  let isError = false;
+  let message = '';
+  const emptyValidationMethod = emptyValidateMapping[fieldType];
+  const isEmptyValue = emptyValidationMethod ? validator[emptyValidationMethod](value) : validator.isEmpty(value);
+
+  if (isMandatory && isEmptyValue || isMandatory && fieldType === 'Boolean' && (value === false || value === 'false')) {
+    isError = true;
+    message = i18NProviderUtils.getI18NValue('crm.field.empty.check', fieldLabel);
+  } else if (maxLength && fieldType !== 'Boolean' && fieldType !== 'DateTime' && fieldType !== 'Date' && validator.isMaxLength(value, maxLength)) {
+    isError = true;
+    message = i18NProviderUtils.getI18NValue('support.form.more.than.max.length', [fieldLabel, maxLength]);
+  } else if (!isEmptyValue && validationMethod && !validator[validationMethod](value)) {
+    isError = true;
+    message = i18NProviderUtils.getI18NValue('crm.field.valid.check', fieldLabel);
+  } else if (!isEmptyValue && (fieldType === 'Currency' || fieldType === 'Decimal') && !validator.isValidDecimalPlaces(value, decimalPlaces)) {
+    isError = true;
+    message = i18NProviderUtils.getI18NValue('support.form.decimal.places.length.error.message', decimalPlaces);
+  }
+
+  return {
+    isError,
+    message
+  };
+}

package/es/library/behaviours/keyboard-controls/adapters/gateways/KeyboardHandler.js

@@ -1,11 +1,7 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 import { KEYBOARD_CONTROL_DOWN_ARROW_PRESSED, KEYBOARD_CONTROL_ENTER_PRESSED, KEYBOARD_CONTROL_SPACE_PRESSED, KEYBOARD_CONTROL_UP_ARROW_PRESSED } from "../../../../../bc/keyboard-controls/Constants";
 
 class KeyboardHandler {
   constructor() {
-    _defineProperty(this, "dispatch", void 0);
-
     this.handleKeypress = this.handleKeypress.bind(this);
     this.initialize = this.initialize.bind(this);
     this.destruct = this.destruct.bind(this);

package/es/library/behaviours/keyboard-controls/adapters/gateways/Repository.js

@@ -1,19 +1,11 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 import KeyboardControls from "../../domain/entities/KeyboardControls";
 
 class Repository {
-  constructor() {
-    _defineProperty(this, "state", void 0);
-  }
-
   init(state) {
     this.state = state;
   }
 
   getKeyboardControls() {
-    var _zrecord$records;
-
     const {
       behaviours,
       properties
@@ -21,7 +13,7 @@ class Repository {
     const {
       keyboardControlsConfig
     } = properties;
-    let isKeyboardControlEnabled = keyboardControlsConfig === null || keyboardControlsConfig === void 0 ? void 0 : keyboardControlsConfig.isEnabled;
+    let isKeyboardControlEnabled = keyboardControlsConfig?.isEnabled;
 
     if (!isKeyboardControlEnabled) {
       return null;
@@ -38,7 +30,7 @@ class Repository {
     } = keyboardControls;
     /* eslint-disable-next-line @zohodesk/architecturerules/no-defaultProps-rule */
 
-    const totalRows = (zrecord === null || zrecord === void 0 ? void 0 : (_zrecord$records = zrecord.records) === null || _zrecord$records === void 0 ? void 0 : _zrecord$records.length) || 0;
+    const totalRows = zrecord?.records?.length || 0;
     return new KeyboardControls(focussedIndex, totalRows);
   }
 

package/es/library/behaviours/keyboard-controls/adapters/gateways/Service.js

@@ -1,5 +1,3 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 import DestructUsecase from "../../applications/usecases/DestructUsecase";
 import DownArrowPress from "../../applications/usecases/DownArrowPress";
 import EnterPress from "../../applications/usecases/EnterPress"; // import FocusNextUsecase from "../../applications/usecases/FocusNextUsecase";
@@ -13,18 +11,6 @@ class Service {
   // FocusPreviousUsecase: FocusPreviousUsecase;
   // FocusNextUsecase: FocusNextUsecase;
   constructor(dependencies) {
-    _defineProperty(this, "UpArrowPressUsecase", void 0);
-
-    _defineProperty(this, "DownArrowPressUsecase", void 0);
-
-    _defineProperty(this, "SpacePressUsecase", void 0);
-
-    _defineProperty(this, "EnterPressUsecase", void 0);
-
-    _defineProperty(this, "InitializeUsecase", void 0);
-
-    _defineProperty(this, "DestructUsecase", void 0);
-
     this.UpArrowPressUsecase = new UpArrowPress(dependencies);
     this.DownArrowPressUsecase = new DownArrowPress(dependencies);
     this.SpacePressUsecase = new SpacePress(dependencies);