@heartlandone/vega-sandbox-pr-1521-50c1985674900121427674628ab8007f890f27d7 2.27.0

package/dist/collection/helpers/validator/rules/email-field-rule.js

@@ -0,0 +1,55 @@
+import { EMAIL_VALIDATION_REGEX } from '../../../constants/validator';
+/**
+ * This class is a rule that checks if the input is a valid email address
+ *
+ * @implements {FormFieldValidationRule<string>}
+ */
+export class EmailFieldRule {
+  /**
+   * It checks if the input is a valid email address.
+   *
+   * @param {string} input - string
+   * @returns {EvaluateResultTranslation} An object with two properties: isValid and message.
+   * @throws {Error} if input is unable to evaluate
+   */
+  evaluate(input) {
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Unexpected type of input: ${typeof input}: ${input}`);
+    }
+    const isValid = EMAIL_VALIDATION_REGEX.test(input.toLowerCase());
+    return {
+      isValid: isValid,
+      message: isValid ? '' : 'Please enter the correct email format.',
+    };
+  }
+  /**
+   * If the input is accepted and the status is not disabled and visible, then return true
+   *
+   * @param {unknown} input - The input to be evaluated.
+   * @param {FormFieldStatusMeta} [status] - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  canEvaluate(input, status) {
+    return status
+      ? this.isAcceptedInputType(input) && !status.disabled && status.visible
+      : this.isAcceptedInputType(input);
+  }
+  /**
+   * If the field is not disabled, visible, and has been touched or modified, then show the error
+   *
+   * @param {FormFieldStatusMeta} status - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  shouldShowError(status) {
+    return !status.disabled && status.visible && (status.touched || status.modified);
+  }
+  /**
+   * This function returns true if the input is a string with a length greater than zero, otherwise it returns false.
+   *
+   * @param {unknown} input - The input to be validated.
+   * @returns {boolean} A boolean value.
+   */
+  isAcceptedInputType(input) {
+    return typeof input === 'string' && input.length > 0;
+  }
+}

package/dist/collection/helpers/validator/rules/file-uploader-required-rule.js

@@ -0,0 +1,16 @@
+import { RequiredFieldRule } from './required-field-rule';
+/**
+ * A rule that checks if file-uploader value is empty or not
+ */
+export class FileUploaderRequiredRule extends RequiredFieldRule {
+  constructor() {
+    super(...arguments);
+    /**
+     * re-define the file object array check item type method
+     *
+     * @param {unknown} item the array item
+     * @returns {boolean} true or false
+     */
+    this.checkArrayItemType = (item) => !!(item && typeof item === 'object');
+  }
+}

package/dist/collection/helpers/validator/rules/input-phone-number-required-rule.js

@@ -0,0 +1,58 @@
+/**
+ * A rule that checks if input phone number is empty or not
+ *
+ * @implements {FormFieldValidationRule<string>}
+ */
+export class InputPhoneNumberRequiredRule {
+  constructor(phoneNumberValueGetter) {
+    this.phoneNumberValueGetter = phoneNumberValueGetter;
+  }
+  /**
+   * It checks if the input is a valid value.
+   *
+   * @param {unknown} input - The value of the input field.
+   * @returns {EvaluateResultTranslation} An object with two properties: isValid and message.
+   */
+  evaluate(input) {
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Invalid value ${input} for input phone number`);
+    }
+    const isValid = this.phoneNumberValueGetter() !== '';
+    return {
+      isValid,
+      message: isValid ? '' : 'This field is required',
+    };
+  }
+  /**
+   * If the input is accepted and the status is not disabled and visible, then return true
+   *
+   * @param {unknown} input - The input to be evaluated.
+   * @param {FormFieldStatusMeta} [status] - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  canEvaluate(input, status) {
+    return status
+      ? this.isAcceptedInputType(input) && !status.disabled && status.visible
+      : this.isAcceptedInputType(input);
+  }
+  /**
+   * If the field is not disabled, visible, and has been touched or modified, then show the error
+   *
+   * @param {FormFieldStatusMeta} status - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  shouldShowError(status) {
+    return !status.disabled && status.visible && (status.touched || status.modified);
+  }
+  /**
+   * If the input is undefined or null, return true, otherwise return true if the input is a string.
+   *
+   * @param {unknown} input - The input value to be validated.
+   * @returns {boolean}A boolean.
+   */
+  isAcceptedInputType(input) {
+    if (input === undefined || input === null)
+      return true;
+    return typeof input === 'string';
+  }
+}

package/dist/collection/helpers/validator/rules/input-range-min-and-max-rule.js

@@ -0,0 +1,92 @@
+/**
+ * A rule that checks if number is in min and max range
+ */
+export class InputRangeMinAndMaxRule {
+  /**
+   * It creates a new instance of the class with the given config.
+   *
+   * @param {{ minValue: number; maxValue: number }} config - config including the minDate and the maxDate
+   * @param {string} config.minValue - The min number
+   * @param {string} config.maxValue - The max number
+   */
+  constructor(config) {
+    /**
+     * Generate an invalid result
+     *
+     * @param {string} message Error message
+     * @returns {EvaluateResultTranslation} invalid validation result
+     */
+    this.invalidResult = (message) => ({
+      isValid: false,
+      message,
+    });
+    /**
+     * Generate a valid result
+     *
+     * @returns {EvaluateResultTranslation} invalid validation result
+     */
+    this.validResult = () => ({
+      isValid: true,
+      message: '',
+    });
+    this.minValue = config.minValue === 0 || config.minValue ? Number(config.minValue) : null;
+    this.maxValue = config.maxValue === 0 || config.maxValue ? Number(config.maxValue) : null;
+  }
+  /**
+   * If the input is accepted and the status is not disabled and visible, then return true
+   *
+   * @param {unknown} input - The input to be evaluated.
+   * @param {FormFieldStatusMeta} [status] - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  canEvaluate(input, status) {
+    return status
+      ? this.isAcceptedInputType(input) && !status.disabled && status.visible
+      : this.isAcceptedInputType(input);
+  }
+  /**
+   * check if the start value is within the min and max range, and if the end value is within the
+   * max range
+   *
+   * @param {string[]} input - The value of the input range.
+   * @returns  {EvaluateResultTranslation} - The result of the evaluation.
+   */
+  evaluate(input) {
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Unexpected type of input: ${typeof input}: ${input}`);
+    }
+    const startValue = Number(input[0]), endValue = Number(input[1]);
+    if (this.minValue !== null &&
+      ((input[0] !== '' && startValue < this.minValue) || (input[1] !== '' && endValue < this.minValue))) {
+      return this.invalidResult({ key: 'The minimum input value is {0}', args: [this.minValue] });
+    }
+    if (this.maxValue !== null &&
+      ((input[0] !== '' && startValue > this.maxValue) || (input[1] !== '' && endValue > this.maxValue))) {
+      return this.invalidResult({ key: 'The maximum input value is {0}', args: [this.maxValue] });
+    }
+    if (input[0] !== '' && input[1] !== '' && startValue > endValue) {
+      return this.invalidResult(`The end value should be greater than the start value`);
+    }
+    return this.validResult();
+  }
+  /**
+   * If the field is not disabled, visible, and has been touched or modified, then show the error
+   *
+   * @param {FormFieldStatusMeta} status - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  shouldShowError(status) {
+    return !status.disabled && status.visible && (status.touched || status.modified);
+  }
+  /**
+   * It returns true if the input is a string or an array of two strings, and each string is a valid string
+   *
+   * @param {unknown} input - The input value to be validated.
+   * @returns {boolean} A boolean value.
+   */
+  isAcceptedInputType(input) {
+    return (Array.isArray(input) &&
+      input.length === 2 &&
+      input.every((item) => typeof Number(item) === 'number'));
+  }
+}

package/dist/collection/helpers/validator/rules/input-range-required-rule.js

@@ -0,0 +1,57 @@
+/**
+ * A rule that checks if input range is empty or not
+ *
+ * @implements {FormFieldValidationRule<string[]>}
+ */
+export class InputRangeRequiredRule {
+  /**
+   * It checks if the input is a valid value.
+   *
+   * @param {string[]} input - The value of the input field.
+   * @returns {EvaluateResultTranslation} An object with two properties: isValid and message.
+   */
+  evaluate(input) {
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Invalid value ${input} for input range`);
+    }
+    const isValid = Array.isArray(input) &&
+      input.length === 2 &&
+      input.every((item) => !!item || item == '0');
+    return {
+      isValid,
+      message: isValid ? '' : 'This field is required',
+    };
+  }
+  /**
+   * If the input is accepted and the status is not disabled and visible, then return true
+   *
+   * @param {unknown} input - The input to be evaluated.
+   * @param {FormFieldStatusMeta} [status] - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  canEvaluate(input, status) {
+    return status
+      ? this.isAcceptedInputType(input) && !status.disabled && status.visible
+      : this.isAcceptedInputType(input);
+  }
+  /**
+   * If the field is not disabled, visible, and has been touched or modified, then show the error
+   *
+   * @param {FormFieldStatusMeta} status - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  shouldShowError(status) {
+    return !status.disabled && status.visible && (status.touched || status.modified);
+  }
+  /**
+   * If the input is undefined or null, return true, otherwise return true if the input is a string.
+   *
+   * @param {unknown} input - The input value to be validated.
+   * @returns {boolean}A boolean.
+   */
+  isAcceptedInputType(input) {
+    if (input === undefined || input === null)
+      return true;
+    return Array.isArray(input);
+  }
+}

package/dist/collection/helpers/validator/rules/max-number-rule.js

@@ -0,0 +1,68 @@
+import { convertToNumber } from '../../../utils/number';
+/**
+ * A rule that checks if the input is less than or equal to a maximum value
+ *
+ * @implements {FormFieldValidationRule<string>}
+ * @property {{ maxValue: number }} config config including the maxValue limit for validation
+ */
+export class MaxNumberRule {
+  /**
+   * It creates a new instance of the class with the given config.
+   *
+   * @param {{ maxValue: number }} config config including the maxValue limit for validation
+   * @param {number} config.maxValue number of the maxValue
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * If the input is a number, return true if it's less than or equal to the maximum value, false otherwise
+   *
+   * @param {unknown} input - The input value to be evaluated.
+   * @returns {EvaluateResultTranslation} The result of the evaluation.
+   * @throws {Error} if input is unable to evaluate
+   */
+  evaluate(input) {
+    var _a;
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Unexpected type of input: ${typeof input}: ${input}`);
+    }
+    const maxValue = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.maxValue) || Number.MAX_VALUE;
+    return {
+      isValid: convertToNumber(input) <= maxValue,
+      message: convertToNumber(input) <= maxValue
+        ? ''
+        : { key: 'The maximum input value is {0}', args: [maxValue] },
+    };
+  }
+  /**
+   * If the input is accepted and the status is not disabled and visible, then return true
+   *
+   * @param {unknown} input - The input to be evaluated.
+   * @param {FormFieldStatusMeta} [status] - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  canEvaluate(input, status) {
+    return status
+      ? this.isAcceptedInputType(input) && !status.disabled && status.visible
+      : this.isAcceptedInputType(input);
+  }
+  /**
+   * If the field is not disabled, visible, and has been touched or modified, then show the error
+   *
+   * @param {FormFieldStatusMeta} status - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  shouldShowError(status) {
+    return !status.disabled && status.visible && (status.touched || status.modified);
+  }
+  /**
+   * If the input is not a number, then return false, otherwise return true.
+   *
+   * @param {unknown} input - The input value to be converted.
+   * @returns {boolean} a boolean value.
+   */
+  isAcceptedInputType(input) {
+    return !isNaN(convertToNumber(input));
+  }
+}

package/dist/collection/helpers/validator/rules/max-string-length-rule.js

@@ -0,0 +1,67 @@
+/**
+ * A rule that checks if the length of input is less than or equal to a maximum value
+ *
+ * @implements {FormFieldValidationRule<string>}
+ * @property {{ maxStrLength: number }} config config including the maxStrLength limit for validation
+ */
+export class MaxStringLengthRule {
+  /**
+   * It creates a new instance of the class with the given config.
+   *
+   * @param {{ maxStrLength: number }} config config including the maxStrLength limit for validation
+   * @param {number} config.maxStrLength number of the maxStrLength
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * It checks if the input is a string and if it's shorter than the maximum string length
+   *
+   * @param {string} input - string
+   * @returns {EvaluateResultTranslation} An object with two properties: isValid and message.
+   * @throws {Error} if input is unable to evaluate
+   */
+  evaluate(input) {
+    var _a;
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Unexpected type of input: ${typeof input}: ${input}`);
+    }
+    const maxStrLength = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.maxStrLength) || Number.MAX_VALUE;
+    return {
+      isValid: input.length <= maxStrLength,
+      message: input.length <= maxStrLength
+        ? ''
+        : { key: 'The maximum input length is {0}', args: [maxStrLength] },
+    };
+  }
+  /**
+   * It returns true if the input is of an accepted type and the field is not disabled and visible
+   *
+   * @param {unknown} input - The input to be evaluated.
+   * @param {FormFieldStatusMeta} [status] - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  canEvaluate(input, status) {
+    return status
+      ? this.isAcceptedInputType(input) && !status.disabled && status.visible
+      : this.isAcceptedInputType(input);
+  }
+  /**
+   * If the field is not disabled, visible, and has been touched or modified, then show the error
+   *
+   * @param {FormFieldStatusMeta} status - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  shouldShowError(status) {
+    return !status.disabled && status.visible && (status.touched || status.modified);
+  }
+  /**
+   * This function returns true if the input is a string, and false otherwise.
+   *
+   * @param {unknown} input - The input to be validated.
+   * @returns {boolean} A boolean value.
+   */
+  isAcceptedInputType(input) {
+    return typeof input === 'string';
+  }
+}

package/dist/collection/helpers/validator/rules/min-and-max-date-rule.js

@@ -0,0 +1,138 @@
+import { isDateStr, compareIsAfter, compareIsBefore } from '../../../utils/date';
+/**
+ * A rule that checks if date is in minDate and maxDate range
+ */
+export class MinAndMaxDateRule {
+  /**
+   * It creates a new instance of the class with the given config.
+   *
+   * @param {{ minDate: string; maxDate: string }} config - config including the minDate and the maxDate
+   * @param {string} config.minDate - The minDate
+   * @param {string} config.maxDate - The maxDate
+   */
+  constructor(config) {
+    /**
+     *  Evaluate if single date is within the min and max date range
+     *
+     * @param {string} input A single date string
+     * @returns  {EvaluateResultTranslation}An object with two properties: isValid and message.
+     */
+    this.evaluateSingleDate = (input) => {
+      const singleDate = new Date(input);
+      if (this.minDate && compareIsBefore(singleDate, this.minDate)) {
+        return this.invalidResult({
+          key: 'The date should be later than {0}',
+          args: [this.config.minDate],
+        });
+      }
+      if (this.maxDate && compareIsAfter(singleDate, this.maxDate)) {
+        return this.invalidResult({
+          key: 'The date should be earlier than {0}',
+          args: [this.config.maxDate],
+        });
+      }
+      return this.validResult();
+    };
+    /**
+     * Evaluate if start date or end date are within the min and max date range
+     *
+     * @param {string[]} input includes start date or end date
+     * @returns  {EvaluateResultTranslation}An object with two properties: isValid and message.
+     */
+    this.evaluateRangeDates = (input) => {
+      const startDate = new Date(input[0]);
+      const endDate = new Date(input[1]);
+      if (this.minDate && compareIsBefore(startDate, this.minDate)) {
+        return this.invalidResult({
+          key: 'The start date should be later than {0}',
+          args: [this.config.minDate],
+        });
+      }
+      if (this.maxDate && compareIsAfter(startDate, this.maxDate)) {
+        return this.invalidResult({
+          key: 'The start date should be earlier than {0}',
+          args: [this.config.maxDate],
+        });
+      }
+      if (endDate && this.maxDate && compareIsAfter(endDate, this.maxDate)) {
+        return this.invalidResult({
+          key: 'The end date should be earlier than {0}',
+          args: [this.config.maxDate],
+        });
+      }
+      return this.validResult();
+    };
+    /**
+     * Generate an invalid result
+     *
+     * @param {string} message Error message
+     * @returns {EvaluateResultTranslation} invalid validation result
+     */
+    this.invalidResult = (message) => ({
+      isValid: false,
+      message,
+    });
+    /**
+     * Generate a valid result
+     *
+     * @returns {EvaluateResultTranslation} invalid validation result
+     */
+    this.validResult = () => ({
+      isValid: true,
+      message: '',
+    });
+    this.config = config;
+    this.minDate = config.minDate ? new Date(config.minDate) : null;
+    this.maxDate = config.maxDate ? new Date(config.maxDate) : null;
+  }
+  /**
+   * If the input is accepted and the status is not disabled and visible, then return true
+   *
+   * @param {unknown} input - The input to be evaluated.
+   * @param {FormFieldStatusMeta} [status] - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  canEvaluate(input, status) {
+    return status
+      ? this.isAcceptedInputType(input) && !status.disabled && status.visible
+      : this.isAcceptedInputType(input);
+  }
+  /**
+   * If the input is a string, check if it's within the min and max date range.
+   * If the input is an array, check if the start date is within the min and max date range, and if the end date is within the
+   * max date range
+   *
+   * @param {string | string[]} input - The value of the date picker.
+   * @returns  {EvaluateResultTranslation} - The result of the evaluation.
+   */
+  evaluate(input) {
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Unexpected type of input: ${typeof input}: ${input}`);
+    }
+    if (typeof input === 'string') {
+      return this.evaluateSingleDate(input);
+    }
+    else {
+      return this.evaluateRangeDates(input);
+    }
+  }
+  /**
+   * If the field is not disabled, visible, and has been touched or modified, then show the error
+   *
+   * @param {FormFieldStatusMeta} status - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  shouldShowError(status) {
+    return !status.disabled && status.visible && (status.touched || status.modified);
+  }
+  /**
+   * It returns true if the input is a string or an array of two strings, and each string is a valid date string
+   *
+   * @param {unknown} input - The input value to be validated.
+   * @returns {boolean} A boolean value.
+   */
+  isAcceptedInputType(input) {
+    return ((typeof input === 'string' && isDateStr(input)) ||
+      (Array.isArray(input) && input.length === 2 && input.every(isDateStr)));
+  }
+}

package/dist/collection/helpers/validator/rules/min-number-rule.js

@@ -0,0 +1,68 @@
+import { convertToNumber } from '../../../utils/number';
+/**
+ * A rule that checks if the input is larger than or equal to a minimum value
+ *
+ * @implements {FormFieldValidationRule<string>}
+ * @property {{ minValue: number }} config config including the minValue limit for validation
+ */
+export class MinNumberRule {
+  /**
+   * It creates a new instance of the class with the given config.
+   *
+   * @param {{ minValue: number }} config config including the minValue limit for validation
+   * @param {number} config.minValue number of the minValue
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * If the input is a number, return true if it's more than or equal to the minimum value, false otherwise
+   *
+   * @param {unknown} input - The input value to be evaluated.
+   * @returns {EvaluateResultTranslation} The result of the evaluation.
+   * @throws {Error} if input is unable to evaluate
+   */
+  evaluate(input) {
+    var _a;
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Unexpected type of input: ${typeof input}: ${input}`);
+    }
+    const minValue = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.minValue) || 0;
+    return {
+      isValid: convertToNumber(input) >= minValue,
+      message: convertToNumber(input) >= minValue
+        ? ''
+        : { key: 'The minimum input value is {0}', args: [minValue] },
+    };
+  }
+  /**
+   * If the input is accepted and the status is not disabled and visible, then return true
+   *
+   * @param {unknown} input - The input to be evaluated.
+   * @param {FormFieldStatusMeta} [status] - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  canEvaluate(input, status) {
+    return status
+      ? this.isAcceptedInputType(input) && !status.disabled && status.visible
+      : this.isAcceptedInputType(input);
+  }
+  /**
+   * If the field is not disabled, visible, and has been touched or modified, then show the error
+   *
+   * @param {FormFieldStatusMeta} status - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  shouldShowError(status) {
+    return !status.disabled && status.visible && (status.touched || status.modified);
+  }
+  /**
+   * If the input is not a number, then return false, otherwise return true.
+   *
+   * @param {unknown} input - The input value to be converted.
+   * @returns {boolean} a boolean value.
+   */
+  isAcceptedInputType(input) {
+    return !isNaN(convertToNumber(input));
+  }
+}