@globalpayments/vega 2.39.0 → 2.41.0

package/dist/cjs/{responsive-format-facade-a1983026.js → responsive-format-facade-ad8ca2ab.js}

@@ -2,10 +2,20 @@
 
 const typeGuard = require('./type-guard-4ba85fdc.js');
 const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
-const breakpoints = require('./breakpoints-17d6c4c7.js');
+const pageResizeObserverSlimmer = require('./page-resize-observer-slimmer-bceeaabf.js');
 const number = require('./number-4816603d.js');
 const ui = require('./ui-32e69595.js');
 const pixel = require('./pixel-98f2a10c.js');
+const breakpoints = require('./breakpoints-ebde4837.js');
+const array = require('./array-5adef7b2.js');
+require('./vega-env-manager-23b8b23c.js');
+require('./vega-skeleton-loader-controller-381e90fe.js');
+const featureFlagController = require('./feature-flag-controller-3c6666df.js');
+require('./content-state-582d8961.js');
+require('./icon-manager-edc2400b.js');
+require('./wait-for-vega-handler-46280dcf.js');
+require('./ui-5fd9b267.js');
+require('./translation-6848c389.js');
 
 /**
  * An abstract class for format {@link ManagedResponsiveScopeInput[Flag]} to CSS class string
@@ -45,6 +55,7 @@ const PADDING_DIRECTION_CLASS_PARTIAL_MAP = {
 /**
  * A class for format PaddingType with BreakpointsForPrefixType to CSS class string
  *
+ * @deprecated Please use the `ResponsivePaddingStyleFormatter` instead.
  * @augments ResponsiveClassStringFormatter
  */
 class ResponsivePaddingFormatter extends ResponsiveClassStringFormatter {
@@ -86,6 +97,7 @@ const MARGIN_DIRECTION_CLASS_PARTIAL_MAP = {
 /**
  * A class for format MarginType with BreakpointsForPrefixType to CSS class string
  *
+ * @deprecated Please use the `ResponsiveMarginStyleFormatter` instead.
  * @augments ResponsiveClassStringFormatter
  */
 class ResponsiveMarginFormatter extends ResponsiveClassStringFormatter {
@@ -275,7 +287,7 @@ class ResponsiveSizeFormatter {
    * @returns {SizeType} - size.
    */
   format(input) {
-    const breakpoint = breakpoints.getCurrentBreakpoint();
+    const breakpoint = pageResizeObserverSlimmer.getCurrentBreakpoint();
     // string type assertion is needed here, cause if we have <vega-modal size=650/>, stencil is not able to parse it as number but string since the property is a union type of number and string
     if ((typeof input === 'number' || typeof input === 'string') && !isNaN(input)) {
       return Number(input);
@@ -284,7 +296,7 @@ class ResponsiveSizeFormatter {
       return input;
     }
     else if (typeGuard.isResponsiveType(input)) {
-      input = breakpoints.createCompleteResponsiveMap(input);
+      input = pageResizeObserverSlimmer.createCompleteResponsiveMap(input);
       return input[breakpoint];
     }
     else {
@@ -311,8 +323,8 @@ class ResponsiveTranslocationFormatter {
       return input;
     }
     else if (typeGuard.isResponsiveType(input)) {
-      const breakpoint = breakpoints.getCurrentBreakpoint();
-      input = breakpoints.createCompleteResponsiveMap(input);
+      const breakpoint = pageResizeObserverSlimmer.getCurrentBreakpoint();
+      input = pageResizeObserverSlimmer.createCompleteResponsiveMap(input);
       return input[breakpoint];
     }
     else {
@@ -498,9 +510,9 @@ class ResponsiveCustomFormatter {
    * @returns {T} The value of the current breakpoint.
    */
   format(input) {
-    const breakpoint = breakpoints.getCurrentBreakpoint();
+    const breakpoint = pageResizeObserverSlimmer.getCurrentBreakpoint();
     if (typeGuard.isResponsiveType(input)) {
-      input = breakpoints.createCompleteResponsiveMap(input);
+      input = pageResizeObserverSlimmer.createCompleteResponsiveMap(input);
       return input[breakpoint];
     }
     else {
@@ -555,9 +567,9 @@ class ResponsiveWidthAndHeightFormatter {
    * @returns {string} The `format` function returns a string value.
    */
   format(input) {
-    const breakpoint = breakpoints.getCurrentBreakpoint();
+    const breakpoint = pageResizeObserverSlimmer.getCurrentBreakpoint();
     if (typeGuard.isResponsiveType(input)) {
-      input = breakpoints.createCompleteResponsiveMap(input);
+      input = pageResizeObserverSlimmer.createCompleteResponsiveMap(input);
       return pixel.parseToPixelString(input[breakpoint]);
     }
     else {
@@ -580,6 +592,7 @@ const BORDER_RADIUS_DIRECTION_CLASS_PARTIAL_MAP = {
 /**
  * A class for format BorderRadiusType with BreakpointsForPrefixType to CSS class string
  *
+ * @deprecated Please use the `ResponsiveBorderRadiusStyleStyleFormatter` instead.
  * @augments ResponsiveClassStringFormatter
  */
 class ResponsiveBorderRadiusFormatter extends ResponsiveClassStringFormatter {
@@ -646,6 +659,190 @@ class ResponsiveTextAlignFormatter extends ResponsiveClassStringFormatter {
 }
 const ResponsiveTextAlignFormatter$1 = new ResponsiveTextAlignFormatter();
 
+/**
+ * Get the style text from the responsive property.
+ */
+class ResponsiveCSSTextFormatter {
+  /**
+   * > It takes a `ResponsiveType<ManagedResponsiveScopeInput[Flag]>` and returns a string
+   *
+   * @typedef Flag key of ManagedResponsiveScopeInput
+   * @param {ResponsiveType<ManagedResponsiveScopeInput[Flag]>} input - ManagedResponsiveScopeInput[Flag]
+   * @returns {string} - CSS text string.
+   */
+  format(input) {
+    if (typeGuard.isResponsiveType(input)) {
+      return Object.keys(input)
+        .map((breakpoint) => {
+        const breakpointValue = input[breakpoint];
+        const breakPointFormatted = breakpoint !== 'default' ? breakpoint : undefined;
+        return this.generateCssText(this.formatToken(breakpointValue, breakPointFormatted), breakpoint);
+      })
+        .join(' ');
+    }
+    else {
+      return this.generateCssText(this.formatToken(input));
+    }
+  }
+  /**
+   * Create the complete style text with media query selector.
+   *
+   * @param {string} cssText - The style snippet.
+   * @param {BreakpointsTokenType} breakpoint - The screen breakpoint.
+   * @returns {string} - Style content with css selector.
+   */
+  generateCssText(cssText, breakpoint) {
+    let result = '';
+    if (cssText) {
+      result =
+        breakpoint && breakpoint !== 'default'
+          ? `@media (min-width:${breakpoints.Breakpoints[breakpoint]}px){:host{${cssText}}}`
+          : `:host{${cssText}}`;
+    }
+    return result;
+  }
+}
+
+const PADDING_DIRECTION_STYLE_MAP = {
+  top: ['padding-top'],
+  bottom: ['padding-bottom'],
+  left: ['padding-left'],
+  right: ['padding-right'],
+  x: ['padding-left', 'padding-right'],
+  y: ['padding-top', 'padding-bottom'],
+};
+/**
+ * Get the padding style content.
+ */
+class ResponsivePaddingStyleFormatter extends ResponsiveCSSTextFormatter {
+  /**
+   * Given a padding type, return the corresponding string of CSS text.
+   *
+   * @param {PaddingType} input - PaddingType
+   * @returns {string} - CSS text.
+   */
+  formatToken(input) {
+    if (typeGuard.isSpacingTokenType(input)) {
+      return `padding:${typeGuard.Spacing[input]}px`;
+    }
+    else if (typeGuard.isDirectionalSpacingType(input)) {
+      return Object.keys(input)
+        .map((direction) => {
+        return PADDING_DIRECTION_STYLE_MAP[direction]
+          .map((item) => {
+          return `${item}:${typeGuard.Spacing[input[direction]]}px`;
+        })
+          .join(';');
+      })
+        .join(';');
+    }
+    else {
+      globalSlimmerRegistry.LogUtility.warn(`The padding value ${input} is invalid, it must be a value of: `, typeGuard.Spacing);
+      return '';
+    }
+  }
+}
+const responsivePaddingStyleFormatter = new ResponsivePaddingStyleFormatter();
+
+const MARGIN_DIRECTION_STYLE_MAP = {
+  top: ['margin-top'],
+  bottom: ['margin-bottom'],
+  left: ['margin-left'],
+  right: ['margin-right'],
+  x: ['margin-left', 'margin-right'],
+  y: ['margin-top', 'margin-bottom'],
+};
+/**
+ * Get the padding style content.
+ */
+class ResponsiveMarginStyleFormatter extends ResponsiveCSSTextFormatter {
+  /**
+   * Given a margin type, return a string of style content that can be used to apply the margin to an element
+   *
+   * @param {MarginType} input - MarginType
+   * @returns {string} - A string of style content.
+   */
+  formatToken(input) {
+    if (typeGuard.isSpacingTokenType(input)) {
+      return `margin:${typeGuard.Spacing[input]}px`;
+    }
+    else if (typeGuard.isDirectionalSpacingType(input)) {
+      return Object.keys(input)
+        .map((direction) => {
+        return MARGIN_DIRECTION_STYLE_MAP[direction]
+          .map((item) => {
+          return `${item}:${typeGuard.Spacing[input[direction]]}px`;
+        })
+          .join(';');
+      })
+        .join(';');
+    }
+    else {
+      globalSlimmerRegistry.LogUtility.warn(`The margin value ${input} is invalid, it must be a value of: `, typeGuard.Spacing);
+      return '';
+    }
+  }
+}
+const responsiveMarginStyleFormatter = new ResponsiveMarginStyleFormatter();
+
+const BORDER_RADIUS_DIRECTION_STYLE_MAP = {
+  'top': ['border-top-left-radius', 'border-top-right-radius'],
+  'right': ['border-top-right-radius', 'border-bottom-right-radius'],
+  'bottom': ['border-bottom-left-radius', 'border-bottom-right-radius'],
+  'left': ['border-top-left-radius', 'border-bottom-left-radius'],
+  'top-left': ['border-top-left-radius'],
+  'top-right': ['border-top-right-radius'],
+  'bottom-left': ['border-bottom-left-radius'],
+  'bottom-right': ['border-bottom-right-radius'],
+};
+/**
+ * A class for format BorderRadiusType with BreakpointsForPrefixType to CSS text string
+ *
+ * @augments ResponsiveClassStringFormatter
+ */
+class ResponsiveBorderRadiusStyleFormatter extends ResponsiveCSSTextFormatter {
+  /**
+   * Given a border-radius type, return a string of CSS classes that can be used to apply the border-radius to an element
+   *
+   * @param {CornersType} input - CornersType
+   * @returns {string} - A string of CSS text.
+   */
+  formatToken(input) {
+    if (typeGuard.isBorderRadiusTokenType(input)) {
+      return `border-radius:${typeGuard.BorderRadius[input]}px`;
+    }
+    else if (typeGuard.isDirectionalBorderRadiusType(input)) {
+      return this.getDirectionKeys(input)
+        .map((direction) => {
+        return BORDER_RADIUS_DIRECTION_STYLE_MAP[direction]
+          .map((item) => {
+          return `${item}:${typeGuard.BorderRadius[input[direction]]}px`;
+        })
+          .join(';');
+      })
+        .join(';');
+    }
+    else {
+      globalSlimmerRegistry.LogUtility.warn(`The border radius value ${input} is invalid, it must be a value of: `, typeGuard.BorderRadius);
+      return '';
+    }
+  }
+  /**
+   * Get the corners object keys. Order the keys as exist array if the feature flag enabled.
+   * The order affects the weight of the styles.
+   *
+   * @param {DirectionalBorderRadiusType} map - The corners input object.
+   * @returns {string[]} - The input object keys.
+   */
+  getDirectionKeys(map) {
+    const directionKeys = Object.keys(map);
+    return featureFlagController.FeatureFlag.isEnabled('VEGA_COMPONENT.CORNERS_USE_OLD_BEHAVIOR')
+      ? array.sortAsExistArray(directionKeys, (direction) => map[direction], undefined, Object.keys(typeGuard.BorderRadius))
+      : directionKeys;
+  }
+}
+const responsiveBorderRadiusStyleFormatter = new ResponsiveBorderRadiusStyleFormatter();
+
 /**
  * A facade class for delegating format input with different responsive formatters given the flag:
  *
@@ -698,6 +895,12 @@ class ResponsiveFormatFacade {
         return ResponsiveBorderRadiusFormatter$1.format(input);
       case 'textAlign':
         return ResponsiveTextAlignFormatter$1.format(input);
+      case 'paddingStyle':
+        return responsivePaddingStyleFormatter.format(input);
+      case 'marginStyle':
+        return responsiveMarginStyleFormatter.format(input);
+      case 'cornersStyle':
+        return responsiveBorderRadiusStyleFormatter.format(input);
       default:
         throw new Error(`Invalid flag ${flag} passed into ResponsiveFormatFacade`);
     }

package/dist/cjs/rich-text-editor-required-rule-15d9dea1.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const contentState = require('./content-state-582d8961.js');
+const internalFormFieldValidationRule_abstract = require('./internal-form-field-validation-rule.abstract-07cdff46.js');
+
+/**
+ * A rule that checks if the input range is empty or not
+ *
+ * @augments {InternalFormFieldValidationRule<string[]>}
+ */
+class RichTextEditorRequiredRule extends internalFormFieldValidationRule_abstract.InternalFormFieldValidationRule {
+  /**
+   * It checks if the input is a valid value.
+   *
+   * @param {string[]} input - The value of the input field.
+   * @returns {EvaluateResult} An object with two properties: isValid and message.
+   */
+  evaluate(input) {
+    var _a, _b;
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Invalid value ${input} for rich text editor`);
+    }
+    const isValid = ((_a = input === null || input === void 0 ? void 0 : input.blocks) === null || _a === void 0 ? void 0 : _a.length) > 1 || // isValid: true when the length is greater than 1 to keep the same behavior as vega-textarea
+      (((_b = input === null || input === void 0 ? void 0 : input.blocks) === null || _b === void 0 ? void 0 : _b.length) === 1 && input.blocks.some((block) => block.isNotEmpty()));
+    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 VegaRTEContent.
+   *
+   * @param {unknown} input - The input value to be validated.
+   * @returns {boolean} A boolean.
+   */
+  isAcceptedInputType(input) {
+    if (input === undefined || input === null)
+      return true;
+    return input instanceof contentState.VegaRTEContent;
+  }
+}
+
+exports.RichTextEditorRequiredRule = RichTextEditorRequiredRule;

package/dist/cjs/{string-input-formatter-slimmer-f45931fd.js → string-input-formatter-slimmer-83aa7e61.js}

@@ -3,9 +3,9 @@
 const typeGuard = require('./type-guard-4ba85fdc.js');
 const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
 const changeManager = require('./change-manager-a297e4d2.js');
-const domNodeSubjectFactory = require('./dom-node-subject-factory-ce1777a9.js');
+const domNodeSubjectFactory = require('./dom-node-subject-factory-3ec114b8.js');
 const vegaInternalEventId = require('./vega-internal-event-id-bda63e14.js');
-const index = require('./index-0546e2ea.js');
+const index = require('./index-453b89b9.js');
 
 /**
  * String format strategy abstract class

package/dist/cjs/{style-formatter-d446562b.js → style-formatter-c1c9c121.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 const typeGuard = require('./type-guard-4ba85fdc.js');
-const responsiveFormatFacade = require('./responsive-format-facade-a1983026.js');
+const responsiveFormatFacade = require('./responsive-format-facade-ad8ca2ab.js');
 
 /**
  * Fomatter flex styles.

package/dist/cjs/{sub-state-notify-slimmer-b1f1e61a.js → sub-state-notify-slimmer-1a52271c.js}

@@ -3,9 +3,8 @@
 const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
 const dynamicSlimmer = require('./dynamic-slimmer-f31fdfd7.js');
 const changeManager = require('./change-manager-a297e4d2.js');
-const observer = require('./observer-f49483e8.js');
+const domNodeSubjectFactory = require('./dom-node-subject-factory-3ec114b8.js');
 const vegaInternalEventId = require('./vega-internal-event-id-bda63e14.js');
-const domNodeSubjectFactory = require('./dom-node-subject-factory-ce1777a9.js');
 
 /**
  * Sub state notify slimmer
@@ -29,7 +28,7 @@ class SubStateNotifySlimmerBase extends globalSlimmerRegistry.VegaSlimmer {
    * Register the observer in connectedCallback
    */
   connectedCallback() {
-    this.subStateObserver = new observer.Observer(this.isAcceptableObserverPayload.bind(this), (payload) => {
+    this.subStateObserver = new domNodeSubjectFactory.Observer(this.isAcceptableObserverPayload.bind(this), (payload) => {
       payload.callback(this.propValue);
     });
     changeManager.ChangeManager.register(domNodeSubjectFactory.domNodeSubjectFactory.getSubject(this.host, vegaInternalEventId.VegaInternalSubStatePull), this.subStateObserver);

package/dist/cjs/{sub-state-observer-slimmer-02634647.js → sub-state-observer-slimmer-91b89d4d.js}

@@ -1,10 +1,9 @@
 'use strict';
 
 const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
-const observer = require('./observer-f49483e8.js');
+const domNodeSubjectFactory = require('./dom-node-subject-factory-3ec114b8.js');
 const changeManager = require('./change-manager-a297e4d2.js');
 const ui = require('./ui-5fd9b267.js');
-const domNodeSubjectFactory = require('./dom-node-subject-factory-ce1777a9.js');
 const vegaInternalEventId = require('./vega-internal-event-id-bda63e14.js');
 
 var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
@@ -41,7 +40,7 @@ class SubStateObserverSlimmer extends globalSlimmerRegistry.VegaSlimmer {
     if (!this.parent)
       return;
     const { subStates } = this.observerEntry;
-    this.subStateObserver = new observer.Observer(this.isAcceptableObserverPayload, (payload) => {
+    this.subStateObserver = new domNodeSubjectFactory.Observer(this.isAcceptableObserverPayload, (payload) => {
       const subState = subStates.find((subState) => subState.parentStateName === payload.stateName);
       if (subState) {
         this.updateState(subState, payload.value);

package/dist/cjs/time-required-rule-ccf178e7.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const date = require('./date-0a6bb035.js');
+const internalFormFieldValidationRule_abstract = require('./internal-form-field-validation-rule.abstract-07cdff46.js');
+
+/**
+ * A rule that checks if time is empty or not
+ *
+ * @augments {InternalFormFieldValidationRule<string[]>}
+ */
+class TimeRangeRequiredRule extends internalFormFieldValidationRule_abstract.InternalFormFieldValidationRule {
+  /**
+   * 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) {
+    super();
+    this.config = config;
+  }
+  /**
+   * It checks if the input is a valid time string.
+   *
+   * @param {string} input - The value of the input field.
+   * @returns {EvaluateResult} 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) => date.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);
+  }
+}
+
+/**
+ * A rule that checks if time is empty or not
+ *
+ * @augments {InternalFormFieldValidationRule<string>}
+ */
+class TimeRequiredRule extends internalFormFieldValidationRule_abstract.InternalFormFieldValidationRule {
+  /**
+   * 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) {
+    super();
+    this.config = config;
+  }
+  /**
+   * It checks if the input is a valid time string.
+   *
+   * @param {string} input - The value of the input field.
+   * @returns {EvaluateResult} An object with two properties: isValid and message.
+   */
+  evaluate(input) {
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Invalid time value ${input}`);
+    }
+    const isValid = date.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';
+  }
+}
+
+exports.TimeRangeRequiredRule = TimeRangeRequiredRule;
+exports.TimeRequiredRule = TimeRequiredRule;

package/dist/cjs/toggle-switch-required-rule-88a51b36.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const internalFormFieldValidationRule_abstract = require('./internal-form-field-validation-rule.abstract-07cdff46.js');
+
+/**
+ * A rule that checks if the toggle switch is required to switch on
+ *
+ * @augments {InternalFormFieldValidationRule<boolean>}
+ */
+class ToggleSwitchRequiredRule extends internalFormFieldValidationRule_abstract.InternalFormFieldValidationRule {
+  /**
+   * 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';
+  }
+}
+
+exports.ToggleSwitchRequiredRule = ToggleSwitchRequiredRule;

package/dist/cjs/{valid-credit-card-number-rule-4a9ae5d9.js → valid-credit-card-number-rule-4a1b00b8.js}

@@ -2,13 +2,14 @@
 
 const regex = require('./regex-c1f70fd4.js');
 const number = require('./number-4816603d.js');
+const internalFormFieldValidationRule_abstract = require('./internal-form-field-validation-rule.abstract-07cdff46.js');
 
 /**
  * A rule that checks if it's a valid credit card number
  *
- * @implements {FormFieldValidationRule<string>}
+ * @augments {InternalFormFieldValidationRule<string>}
  */
-class ValidCreditCardNumberRule {
+class ValidCreditCardNumberRule extends internalFormFieldValidationRule_abstract.InternalFormFieldValidationRule {
   /**
    * 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