@heartlandone/vega-sandbox-pr-1494-3429ea05d798af3eefc4108466681158e05dc68d 2.27.0

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

@@ -0,0 +1,70 @@
+/**
+ * A rule that checks if the length of input is more than or equal to a minimum value
+ *
+ * @implements {FormFieldValidationRule<string>}
+ * @property {{ minStrLength: number }} config config including the minStrLength limit for validation
+ */
+export class MinStringLengthRule {
+  /**
+   * It creates a new instance of the class with the given config.
+   *
+   * @param {{ minStrLength: number }} config config including the minStrLength limit for validation
+   * @param {number} config.minStrLength number of the minStrLength
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * It checks if the input is a string and if it's longer than the minimum 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 minStrLength = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.minStrLength) || 0;
+    return {
+      isValid: input.length >= minStrLength,
+      message: input.length >= minStrLength
+        ? ''
+        : {
+          key: 'The minimum input length is {0}',
+          args: [minStrLength],
+        },
+    };
+  }
+  /**
+   * 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, and false otherwise.
+   *
+   * @param {unknown} input - The input value to be validated.
+   * @returns {boolean} A boolean value.
+   */
+  isAcceptedInputType(input) {
+    return typeof input === 'string';
+  }
+}

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

@@ -0,0 +1,79 @@
+/**
+ * A rule that checks if a string is empty or not
+ *
+ * @implements {FormFieldValidationRule<string>}
+ */
+export class RequiredFieldRule {
+  constructor() {
+    /**
+     * A function that checks if the item is a string, number, or boolean.
+     *
+     * @param {unknown} item - The item to be checked.
+     * @returns {boolean} The return value is a boolean that indicates whether the item is string, number or boolean.
+     */
+    this.checkArrayItemType = (item) => typeof item === 'string' || typeof item === 'number' || typeof item === 'boolean';
+  }
+  /**
+   * If the input is a number or a boolean, return true. If the input is a string, return true if the string is not empty
+   *
+   * @param {FormFieldValueType | Array<FormFieldValueType>} input - The input to be evaluated.
+   * @returns {EvaluateResultTranslation} An object with two properties: isValid and message.
+   */
+  evaluate(input) {
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Unexpected type of input: ${typeof input}: ${input}`);
+    }
+    else if (typeof input === 'number' || typeof input === 'boolean') {
+      return {
+        isValid: true,
+        message: '',
+      };
+    }
+    else if (typeof input === 'string' || Array.isArray(input)) {
+      return {
+        isValid: input.length > 0,
+        message: input.length <= 0 ? 'This field is required' : '',
+      };
+    }
+    else {
+      return {
+        isValid: false,
+        message: '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} The return value is a boolean that indicates whether the input can be evaluated.
+   */
+  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 a string, number, boolean, or null, return true, otherwise return false.
+   *
+   * @param {unknown} input - The input value to be validated.
+   * @returns {boolean} a boolean value.
+   */
+  isAcceptedInputType(input) {
+    return (typeof input === 'string' ||
+      typeof input === 'number' ||
+      typeof input === 'boolean' ||
+      (Array.isArray(input) && input.every(this.checkArrayItemType)) ||
+      input === null);
+  }
+}

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

@@ -0,0 +1,67 @@
+import { isTimeStr } from '../../../utils/date';
+/**
+ * A rule that checks if time is empty or not
+ *
+ * @implements {FormFieldValidationRule<string[]>}
+ */
+export class TimeRangeRequiredRule {
+  /**
+   * It creates a new instance of the class with the given config.
+   *
+   * @param {{ timeFormat: TimeFormat }} config - config including the timeFormat for time value
+   * @param {TimeFormat} config.timeFormat - The timeFormat for time value
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * It checks if the input is a valid time string.
+   *
+   * @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 time value ${input} for range mode`);
+    }
+    const isValid = Array.isArray(input) &&
+      input.length === 2 &&
+      input.every((item) => isTimeStr(item, this.config.timeFormat));
+    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/time-range-rule.js

@@ -0,0 +1,79 @@
+import { convert12HourTo24HourFormat, isTimeStr } from '../../../utils/date';
+/**
+ * A rule that checks if start time is before than end time
+ */
+export class TimeRangeRule {
+  /**
+   * It creates a new instance of the class with the given config.
+   *
+   * @param {{ timeFormat: TimeFormat }} config - config including the timeFormat for time value
+   * @param {TimeFormat} config.timeFormat - The timeFormat for time value
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Check if the start time is before than end time
+   *
+   * @param {string | string[]} input - The value of the time picker.
+   * @returns  {EvaluateResultTranslation} - The result of the evaluation.
+   */
+  evaluate(input) {
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Unexpected type of input: ${typeof input}: ${input}`);
+    }
+    const isValid = this.isStartTimeBeforeEndTime(input[0], input[1]);
+    return {
+      isValid: isValid,
+      message: isValid ? '' : 'The end time should be later than start time',
+    };
+  }
+  /**
+   * If the input is an array of two strings, and each string is a valid date, then return true.
+   *
+   * @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) => isTimeStr(item, this.config.timeFormat)));
+  }
+  /**
+   * check if start time before end time, the 12-hour time should convert to 24-hour time format, the safari, 'fire fox' do not support 12-hour
+   *
+   * @param {string} startTime time string
+   * @param  {string} endTime time string
+   * @returns {boolean} boolean value
+   */
+  isStartTimeBeforeEndTime(startTime, endTime) {
+    const date = new Date();
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const baseDate = `${year}-${month}-${day}`;
+    return (new Date(`${baseDate}T${convert12HourTo24HourFormat(endTime)}`) >
+      new Date(`${baseDate}T${convert12HourTo24HourFormat(startTime)}`));
+  }
+}

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

@@ -0,0 +1,65 @@
+import { isTimeStr } from '../../../utils/date';
+/**
+ * A rule that checks if time is empty or not
+ *
+ * @implements {FormFieldValidationRule<string>}
+ */
+export class TimeRequiredRule {
+  /**
+   * It creates a new instance of the class with the given config.
+   *
+   * @param {{ timeFormat: TimeFormat }} config - config including the timeFormat for time value
+   * @param {TimeFormat} config.timeFormat - The timeFormat for time value
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * It checks if the input is a valid time string.
+   *
+   * @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 time value ${input}`);
+    }
+    const isValid = isTimeStr(input, this.config.timeFormat);
+    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/toggle-switch-required-rule.js

@@ -0,0 +1,60 @@
+/**
+ * A rule that checks if toggle switch is required to switch on
+ *
+ * @implements {FormFieldValidationRule<boolean>}
+ */
+export class ToggleSwitchRequiredRule {
+  /**
+   * If the input is a boolean, return a boolean. If the
+   * input is anything else, return false
+   *
+   * @param {unknown} input - The input to be evaluated.
+   * @returns {EvaluateResult} - An object with two properties: isValid and message.
+   */
+  evaluate(input) {
+    if (typeof input === 'boolean') {
+      return {
+        isValid: input,
+        message: input ? '' : 'This field is required',
+      };
+    }
+    else {
+      return {
+        isValid: false,
+        message: '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} The return value is a boolean that indicates whether the input can be evaluated.
+   */
+  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 boolean.
+   *
+   * @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 === 'boolean';
+  }
+}

package/dist/collection/helpers/validator/rules/valid-credit-card-number-rule.js

@@ -0,0 +1,167 @@
+import { AmexRegex, DiscoverRegex, MasterCardRegex, VisaRegex } from '../../../constants/regex';
+import { mapParityDigits, mapStringToNumberArray, sum } from '../../../utils/number';
+/**
+ * A rule that checks if it's a valid credit card number
+ *
+ * @implements {FormFieldValidationRule<string>}
+ */
+export class ValidCreditCardNumberRule {
+  /**
+   * It takes a string, maps it to an array of numbers, reverses the array, checks the length of the
+   * array, maps the even digits to a new array, sums the new array, and returns true if the sum is
+   * divisible by 10
+   *
+   * @param {string} value - string - The card number to validate
+   * @returns {boolean} A function that takes a string and returns a boolean.
+   */
+  static validateCreditCardDigits(value) {
+    const cardNumberArray = mapStringToNumberArray(value).reverse();
+    if (cardNumberArray.length < 12 || cardNumberArray.length > 19) {
+      return false;
+    }
+    const checkSum = mapParityDigits(cardNumberArray, (index) => index % 2 === 0).reduce(sum, 0);
+    return checkSum % 10 === 0;
+  }
+  /**
+   * It checks if the credit card number is valid.
+   *
+   * @param {string} input - The input value to be evaluated.
+   * @returns {EvaluateResult} an object with two properties: isValid and message.
+   */
+  evaluate(input) {
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Unexpected type of input: ${typeof input}: ${input}`);
+    }
+    const formattedCardNumber = this.formatCreditCardNumber(input);
+    const isValid = this.isValidVisaCreditCard(input) ||
+      this.isValidAmexCreditCard(input) ||
+      this.isValidDiscoverCreditCard(input) ||
+      this.isValidMasterCardCreditCard(input) ||
+      (!this.isSupportedCreditCardType(formattedCardNumber) &&
+        ValidCreditCardNumberRule.validateCreditCardDigits(formattedCardNumber));
+    return {
+      isValid,
+      message: isValid ? '' : 'Credit card number is invalid',
+    };
+  }
+  /**
+   * 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} The return value is a boolean that indicates whether the input can be evaluated.
+   */
+  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);
+  }
+  /**
+   * The function `isValidVisaCreditCard` checks if a given card number is a valid Visa credit card number.
+   *
+   * @param {string} cardNumber - The `cardNumber` parameter is a string representing a credit card
+   * number that needs to be validated as a Visa credit card.
+   * @returns {boolean} a boolean value indicating whether the provided card number is a valid Visa credit card.
+   */
+  isValidVisaCreditCard(cardNumber) {
+    const formattedCardNumber = this.formatCreditCardNumber(cardNumber);
+    return (VisaRegex.test(formattedCardNumber) &&
+      (formattedCardNumber.length === 13 ||
+        formattedCardNumber.length === 16 ||
+        formattedCardNumber.length === 19) &&
+      ValidCreditCardNumberRule.validateCreditCardDigits(formattedCardNumber));
+  }
+  /**
+   * The function `isValidMasterCardCreditCard` checks if a given credit card number is a valid Mastercard number.
+   *
+   * @param {string} cardNumber - The `cardNumber` parameter is a string representing a credit card
+   * number that needs to be validated to determine if it belongs to a Mastercard.
+   * @returns {boolean} The function isValidMasterCardCreditCard is returning a boolean value, which indicates whether the
+   * provided card number is a valid Mastercard.
+   */
+  isValidMasterCardCreditCard(cardNumber) {
+    const formattedCardNumber = this.formatCreditCardNumber(cardNumber);
+    return (MasterCardRegex.test(formattedCardNumber) &&
+      formattedCardNumber.length === 16 &&
+      ValidCreditCardNumberRule.validateCreditCardDigits(formattedCardNumber));
+  }
+  /**
+   * The function `isValidAmexCreditCard` checks if a given credit card number is a valid American Express
+   * card number.
+   *
+   * @param {string} cardNumber - The `cardNumber` parameter is a string representing a credit card
+   * number that needs to be validated as an American Express credit card.
+   * @returns {boolean} The `isValidAmexCreditCard` function is returning a boolean value, which indicates whether the
+   * provided `cardNumber` is a valid American Express credit card.
+   */
+  isValidAmexCreditCard(cardNumber) {
+    const formattedCardNumber = this.formatCreditCardNumber(cardNumber);
+    return (AmexRegex.test(formattedCardNumber) &&
+      formattedCardNumber.length === 15 &&
+      ValidCreditCardNumberRule.validateCreditCardDigits(formattedCardNumber));
+  }
+  /**
+   * The function `isValidDiscoverCreditCard` checks if a given credit card number is a valid Discover card
+   * number.
+   *
+   * @param {string} cardNumber - The `cardNumber` parameter is a string representing a credit card
+   * number that needs to be validated as a Discover credit card.
+   * @returns {boolean} a boolean value indicating whether the provided card number is a valid Discover credit
+   * card.
+   */
+  isValidDiscoverCreditCard(cardNumber) {
+    const formattedCardNumber = this.formatCreditCardNumber(cardNumber);
+    return (DiscoverRegex.test(formattedCardNumber) &&
+      formattedCardNumber.length === 16 &&
+      ValidCreditCardNumberRule.validateCreditCardDigits(formattedCardNumber));
+  }
+  /**
+   * If the input is not a string, then return false, otherwise return true.
+   *
+   * @param {unknown} input - The input value to be validated.
+   * @returns {boolean} a boolean value.
+   */
+  isAcceptedInputType(input) {
+    return typeof input === 'string';
+  }
+  /**
+   * The `formatCreditCardNumber` function removes all spaces from a given credit card number string.
+   *
+   * @param {string} cardNumber - The `cardNumber` parameter is a string representing a credit card
+   * number. The `formatCreditCardNumber` function removes any white space characters from the input
+   * `cardNumber` string and returns the formatted credit card number.
+   * @returns {string} The `formatCreditCardNumber` function returns the `cardNumber` string with all spaces
+   * removed.
+   */
+  formatCreditCardNumber(cardNumber) {
+    return cardNumber.replace(/\s/g, '');
+  }
+  /**
+   * The function checks if a given credit card number matches any of the supported card types (Visa,
+   * MasterCard, Amex, Discover).
+   *
+   * @param {string} formattedCardNumber - The `formattedCardNumber` parameter is a string representing a
+   * credit card number that has been formatted in a specific way. The function
+   * `isSupportedCreditCardType` checks if the provided credit card number matches any of the regular
+   * expressions for Visa, MasterCard, American Express (Amex), or Discover
+   * @returns {boolean} The `isSupportedCreditCardType` function is returning a boolean value based on whether the
+   * `formattedCardNumber` matches any of the regular expressions for Visa, MasterCard, American Express
+   * (Amex), or Discover credit card types. If the `formattedCardNumber` matches any of these card types,
+   * the function will return `true`, indicating that the credit card type is supported. Otherwise, it
+   */
+  isSupportedCreditCardType(formattedCardNumber) {
+    return (VisaRegex.test(formattedCardNumber) ||
+      MasterCardRegex.test(formattedCardNumber) ||
+      AmexRegex.test(formattedCardNumber) ||
+      DiscoverRegex.test(formattedCardNumber));
+  }
+}