@globalpayments/vega 2.18.1 → 2.20.0

package/dist/collection/helpers/event-manager/test/internalVegaEventManager.test.js

@@ -1,70 +0,0 @@
-import InternalVegaEventManager from '../internalVegaEventManager';
-describe('EventManager', () => {
-  it('should return default event semantics while user no set', () => {
-    expect(InternalVegaEventManager.getSemantics(document.createElement('vega-accordion'))).toEqual({
-      namespace: 'vega',
-    });
-  });
-  it('should work proper while eventSemantics has be set as global', () => {
-    InternalVegaEventManager.setSemantics({
-      global: {
-        namespace: 'native',
-        jqueryDelegatedEvent: true,
-      },
-    });
-    expect(InternalVegaEventManager.getSemantics(document.createElement('vega-accordion'))).toEqual({
-      namespace: 'native',
-      jqueryDelegatedEvent: true,
-    });
-    expect(InternalVegaEventManager.getSemantics(document.createElement('vega-button'))).toEqual({
-      namespace: 'native',
-      jqueryDelegatedEvent: true,
-    });
-  });
-  it('should work proper while eventSemantics has be set as component', () => {
-    InternalVegaEventManager.setSemantics({
-      components: {
-        'vega-accordion': {
-          namespace: 'native',
-          jqueryDelegatedEvent: true,
-        },
-      },
-    });
-    expect(InternalVegaEventManager.getSemantics(document.createElement('vega-accordion'))).toEqual({
-      namespace: 'native',
-      jqueryDelegatedEvent: true,
-    });
-    expect(InternalVegaEventManager.getSemantics(document.createElement('vega-button'))).toEqual({
-      namespace: 'vega',
-    });
-  });
-  it('should work proper while eventSemantics has be both set as component and global', () => {
-    InternalVegaEventManager.setSemantics({
-      global: {
-        namespace: 'vega',
-        jqueryDelegatedEvent: true,
-      },
-      components: {
-        'vega-accordion': {
-          namespace: 'native',
-          jqueryDelegatedEvent: true,
-        },
-        'vega-button': {
-          namespace: 'native',
-        },
-      },
-    });
-    expect(InternalVegaEventManager.getSemantics(document.createElement('vega-accordion'))).toEqual({
-      namespace: 'native',
-      jqueryDelegatedEvent: true,
-    });
-    expect(InternalVegaEventManager.getSemantics(document.createElement('vega-button'))).toEqual({
-      namespace: 'native',
-      jqueryDelegatedEvent: true,
-    });
-    expect(InternalVegaEventManager.getSemantics(document.createElement('vega-icon'))).toEqual({
-      namespace: 'vega',
-      jqueryDelegatedEvent: true,
-    });
-  });
-});

package/dist/collection/helpers/event-manager/test/jqueryDelegatedStrategyController.test.js

@@ -1,131 +0,0 @@
-import { LogUtility } from '../../../utils/log';
-import { VegaJQueryDelegatedEventStrategy } from '../../publicApi';
-import jqueryDelegatedStrategyController from '../event-delegated/jqueryDelegatedStrategyController';
-import { VegaInputStrategy } from '../event-delegated/vegaInputStrategy';
-import { VegaChange, VegaClick } from '../eventID/vegaEventId';
-import internalVegaEventManager from '../internalVegaEventManager';
-class ButtonCircleFocus extends VegaJQueryDelegatedEventStrategy {
-  constructor() {
-    super(...arguments);
-    this.eventName = 'focus';
-    this.vegaComponentName = 'vega-button-circle';
-  }
-  createEventTarget() {
-    return document.createElement('button');
-  }
-  createEvent(eventName) {
-    return new FocusEvent(eventName);
-  }
-}
-test('jqueryDelegatedStrategyController isSupportDelegated', () => {
-  const button = document.createElement('vega-button');
-  const buttonCircle = document.createElement('vega-button-circle');
-  internalVegaEventManager.setSemantics({ global: { namespace: 'native', jqueryDelegatedEvent: true } });
-  expect(jqueryDelegatedStrategyController.isSupportDelegated(button, VegaClick)).toBeTruthy();
-  expect(jqueryDelegatedStrategyController.isSupportDelegated(buttonCircle, VegaClick)).toBeFalsy();
-  internalVegaEventManager.setSemantics({ global: { namespace: 'vega' } });
-});
-test('jqueryDelegatedStrategyController strategyRegistry', () => {
-  expect(jqueryDelegatedStrategyController['strategyRegistry'].size).not.toEqual(0);
-  jqueryDelegatedStrategyController['strategyRegistry'].forEach((strategyMap, name) => {
-    strategyMap.forEach((strategy) => {
-      const delegatedTarget = document.createElement(name);
-      if (name === 'vega-input-select') {
-        delegatedTarget['value'] = 'testValue';
-      }
-      expect(strategy['createEventTarget'](delegatedTarget)).not.toBeNull();
-    });
-  });
-});
-test('jqueryDelegatedStrategyController getStrategy', () => {
-  internalVegaEventManager.setSemantics({
-    global: { namespace: 'vega', jqueryDelegatedEvent: false },
-    components: { 'vega-input': { namespace: 'native', jqueryDelegatedEvent: true } },
-  });
-  const vegaInput = document.createElement('vega-input');
-  const strategy = jqueryDelegatedStrategyController.getStrategy(vegaInput, VegaChange);
-  expect(strategy).not.toBeNull();
-  expect(strategy.createEventTarget(vegaInput).tagName).toEqual('INPUT');
-  const mockChange = jest.fn();
-  vegaInput.addEventListener('change', mockChange);
-  const event = strategy.handle(vegaInput, 'testDetail');
-  expect(mockChange).toBeCalledTimes(1);
-  expect(event.target['tagName']).toEqual('INPUT');
-  expect(event['detail']).toEqual('testDetail');
-  internalVegaEventManager.setSemantics({ global: { namespace: 'vega' } });
-});
-test('jqueryDelegatedStrategyController strategy event type', () => {
-  const vegaButton = document.createElement('vega-button-circle');
-  const strategy = new ButtonCircleFocus();
-  const event = strategy.handle(vegaButton);
-  expect(event instanceof FocusEvent).toBeTruthy();
-});
-test('jqueryDelegatedStrategyController getStrategy', () => {
-  internalVegaEventManager.setSemantics({
-    global: { namespace: 'vega', jqueryDelegatedEvent: false },
-    components: {
-      'vega-input': { namespace: 'native', jqueryDelegatedEvent: [new VegaInputStrategy('click')] },
-    },
-  });
-  const vegaInput = document.createElement('vega-input');
-  const strategy = jqueryDelegatedStrategyController.getStrategy(vegaInput, VegaClick);
-  expect(strategy).not.toBeNull();
-  expect(strategy.createEventTarget(vegaInput).tagName).toEqual('INPUT');
-  const event = strategy.handle(vegaInput);
-  expect(event instanceof MouseEvent).toBeTruthy();
-});
-test('jqueryDelegatedStrategyController updateRegistryFromEventSemantics', () => {
-  internalVegaEventManager.setSemantics({
-    components: {
-      'vega-input': { namespace: 'native', jqueryDelegatedEvent: [new VegaInputStrategy('click')] },
-    },
-  });
-  const vegaInput = document.createElement('vega-input');
-  let strategy = jqueryDelegatedStrategyController.getStrategy(vegaInput, VegaClick);
-  expect(strategy).not.toBeNull();
-  internalVegaEventManager.setSemantics({
-    global: { namespace: 'native', jqueryDelegatedEvent: [new VegaInputStrategy('click')] },
-  });
-  strategy = jqueryDelegatedStrategyController.getStrategy(vegaInput, VegaClick);
-  expect(strategy).not.toBeNull();
-  internalVegaEventManager.setSemantics({ global: { namespace: 'vega' } });
-});
-test('jqueryDelegatedStrategy copyAttributeToTarget', () => {
-  internalVegaEventManager.setSemantics({
-    components: {
-      'vega-input': { namespace: 'native', jqueryDelegatedEvent: [new VegaInputStrategy('click')] },
-    },
-  });
-  const vegaInput = document.createElement('vega-input');
-  vegaInput.type = 'password';
-  vegaInput.className = 'custom-className';
-  vegaInput.setAttribute('data-id', '001');
-  vegaInput.setAttribute('data-role', 'test');
-  const strategy = jqueryDelegatedStrategyController.getStrategy(vegaInput, VegaClick);
-  expect(strategy).not.toBeNull();
-  const target = strategy.createEventTarget(vegaInput);
-  expect(target.getAttribute('type')).toEqual(vegaInput.type);
-  expect(target.getAttribute('class').indexOf('custom-className') >= 0).toBeTruthy();
-  expect(target.getAttribute('data-id')).toEqual(vegaInput.dataset.id);
-  expect(target.getAttribute('data-role')).toEqual(vegaInput.dataset.role);
-});
-test('jqueryDelegatedStrategy copyAttributeToTarget throw error', () => {
-  const testStrategy = new VegaInputStrategy('change');
-  const vegaInput = document.createElement('vega-input');
-  vegaInput.setAttribute('data-test', 'test');
-  vegaInput.setAttribute('data-test-error', '');
-  const input = document.createElement('input');
-  const originMethod = input.setAttribute;
-  input.setAttribute = function (name, value) {
-    if (name === 'data-test-error') {
-      throw new Error('Error test');
-    }
-    else {
-      originMethod.call(this, name, value);
-    }
-  };
-  spyOn(LogUtility, 'error');
-  testStrategy['copyAttributesToTarget'](vegaInput, input);
-  expect(LogUtility.error).toBeCalledWith("Delegated strategy copy VEGA-INPUT attribute 'data-test-error' error.");
-  expect(input.hasAttribute('data-test')).toBeTruthy();
-});

package/dist/collection/helpers/event-manager/test/vegaEventId.test.js

@@ -1,16 +0,0 @@
-import { VegaClick, VegaEventID } from '../eventID/vegaEventId';
-const CustomClick = new VegaEventID('customClick', 'click');
-test('VegaEventID#getCurrentName', () => {
-  expect(CustomClick.getCurrentName({ namespace: 'vega' })).toEqual('customClick');
-  expect(CustomClick.getCurrentName({ namespace: 'native' })).toEqual('click');
-});
-test('VegaEventID#getVegaName', () => {
-  expect(CustomClick.getVegaName()).toEqual('customClick');
-});
-test('VegaEventID#getNativeName', () => {
-  expect(CustomClick.getNativeName()).toEqual('click');
-});
-test('VegaEventID#isBrowserRawEvent', () => {
-  expect(CustomClick.isBrowserRawEvent()).toEqual(false);
-  expect(VegaClick.isBrowserRawEvent()).toEqual(true);
-});

package/dist/collection/helpers/event-manager/test/vegaEventManager.test.js

@@ -1,32 +0,0 @@
-import { VegaEventManager } from '../../publicApi';
-import { VegaBlur, VegaChange, VegaCreate, VegaDropdownClick, VegaDropdownHide, VegaDropdownSearch, VegaDropdownShow, VegaFocus, } from '../eventID/vegaEventId';
-describe('VegaEventManager', () => {
-  it('should work proper while call setSemantics/getSemantics', () => {
-    VegaEventManager.setSemantics({
-      components: {
-        'vega-accordion': {
-          namespace: 'native',
-          jqueryDelegatedEvent: true,
-        },
-      },
-    });
-    expect(VegaEventManager.getSemantics(document.createElement('vega-accordion'))).toEqual({
-      namespace: 'native',
-      jqueryDelegatedEvent: true,
-    });
-  });
-  it('should work proper while call getNativeEventName', () => {
-    expect(VegaEventManager.getEnabledEventIdsByComponent('vega-input')).toEqual([
-      VegaChange,
-      VegaFocus,
-      VegaBlur,
-    ]);
-    expect(VegaEventManager.getEnabledEventIdsByComponent('vega-dropdown')).toEqual([
-      VegaDropdownShow,
-      VegaDropdownHide,
-      VegaDropdownClick,
-      VegaCreate,
-      VegaDropdownSearch,
-    ]);
-  });
-});

package/dist/collection/helpers/event-manager/vegaEventManager.js

@@ -1,40 +0,0 @@
-import EventManager from './internalVegaEventManager';
-/**
- * The VegaEventManager class provides methods for setting and retrieving event semantics configuration,
- * as well as getting the corresponding native event name for a given event.
- */
-class VegaEventManager {
-  /**
-   * The function sets the semantics configuration for event management.
-   *
-   * @param {EventSemanticsConfig} config - The config parameter is an object that contains the
-   * configuration settings for the event semantics. It may include properties such as the event type,
-   * event source, event target, event data, and any other relevant information for setting up the
-   * semantics of the event.
-   */
-  setSemantics(config) {
-    EventManager.setSemantics(config);
-  }
-  /**
-   * The function "getSemantics" returns the event semantics of an HTML element.
-   *
-   * @param {HTMLElement} host - The host parameter is an HTMLElement, which represents an HTML element
-   * in the DOM (Document Object Model). It can be any valid HTML element such as a div, span, button,
-   * etc.
-   * @returns {EventSemantics} an object of type EventSemantics.
-   */
-  getSemantics(host) {
-    return EventManager.getSemantics(host);
-  }
-  /**
-   * The function "getEnabledEventIdsByComponent" returns the all eventIds in component.
-   *
-   * @param {VegaComponentName} componentName - The component name,
-   * etc.
-   * @returns {Nullable<VegaEventID[]>} All eventIds.
-   */
-  getEnabledEventIdsByComponent(componentName) {
-    return EventManager.getEnabledEventIdsByComponent(componentName);
-  }
-}
-export default new VegaEventManager();

package/dist/collection/helpers/feature-control/featureFlagController.js

@@ -1,121 +0,0 @@
-import FeatureFlagsMap from './featureFlagsMap';
-import { LogUtility } from '../../utils/log';
-import VegaTelemetryRuntimeMetricsManager from '@globalpayments/vega-telemetry-runtime-metrics/runtime-metrics/src/index';
-/**
- * Feature flag controller to manage feature flags.
- *
- * @class FeatureFlag
- * @property {Set<FeatureFlagKey>} enabledFeatureFlagKeySet - Set of feature flags that are enabled.
- */
-class FeatureFlagController {
-  /**
-   * During constructor, It enables all the feature flags given by {@link FeatureFlagsMap} expect default disabled flags.
-   */
-  constructor() {
-    this.enabledFeatureFlagKeySet = new Set();
-    this.init();
-  }
-  /**
-   * This function enables the feature flags with the given keys.
-   *
-   * @param {FeatureFlagKey[]} featureFlagKeys - The feature flags to enable.
-   */
-  enable(...featureFlagKeys) {
-    featureFlagKeys.forEach((featureFlagKey) => {
-      if (this.versionGuard(featureFlagKey)) {
-        this.enabledFeatureFlagKeySet.add(featureFlagKey);
-        this.sendFeatureFlagKeyToTelemetry(featureFlagKey, true);
-      }
-    });
-  }
-  /**
-   * Disable the feature flags with the given keys.
-   *
-   * @param {FeatureFlagKey[]} featureFlagKeys - The feature flags to disable.
-   */
-  disable(...featureFlagKeys) {
-    featureFlagKeys.forEach((featureFlagKey) => {
-      if (this.versionGuard(featureFlagKey)) {
-        this.enabledFeatureFlagKeySet.delete(featureFlagKey);
-        this.sendFeatureFlagKeyToTelemetry(featureFlagKey, false);
-      }
-    });
-  }
-  /**
-   * If the feature flag key is in the set of enabled feature flag keys, then return true, otherwise return false.
-   *
-   * @param {FeatureFlagKey} featureFlagKey - The feature flag key to check.
-   * @returns {boolean} - True if the feature flag key is in the set of enabled feature flag keys, otherwise false.
-   */
-  isEnabled(featureFlagKey) {
-    return this.enabledFeatureFlagKeySet.has(featureFlagKey);
-  }
-  /**
-   * The `init` function initializes a set of enabled feature flags based on a map of feature flags,
-   * excluding those disabled by default or removed.
-   */
-  init() {
-    Object.keys(FeatureFlagsMap).map((flagKey) => {
-      if (!FeatureFlagsMap[flagKey].disabledByDefault && !this.isRemoved(flagKey)) {
-        this.enabledFeatureFlagKeySet.add(flagKey);
-      }
-    });
-  }
-  /**
-   * Verify if the flag is valid
-   *
-   * @param {FeatureFlagKey} featureFlagKey - the feature flag key
-   * @returns {boolean} return false and console error if the feature flag is removedAfterVersion is not empty
-   */
-  versionGuard(featureFlagKey) {
-    if (this.isRemoved(featureFlagKey)) {
-      LogUtility.error(`The feature flag key '${featureFlagKey}' has been removed after v${FeatureFlagsMap[featureFlagKey].removedAfterVersion}`);
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Verify if the flag is removed or not
-   *
-   * @param {FeatureFlagKey} featureFlagKey - the feature flag key
-   * @returns {boolean} return true if the feature flag removedAfterVersion is not empty
-   */
-  isRemoved(featureFlagKey) {
-    return !!FeatureFlagsMap[featureFlagKey].removedAfterVersion;
-  }
-  /**
-   * The function sends a feature flag key and its value to telemetry if a specific feature flag is
-   * enabled.
-   *
-   * @param {FeatureFlagKey} featureFlagName - The `featureFlagName` parameter is a key that represents
-   * a specific feature flag. It is used to identify and reference a particular feature
-   * flag when checking its status or sending telemetry data related to it.
-   * @param {boolean} featureFlagValue - The `featureFlagValue` parameter is a boolean value that
-   * represents the value of a feature flag. It indicates whether the feature flag is enabled (`true`)
-   * or disabled (`false`).
-   */
-  sendFeatureFlagKeyToTelemetry(featureFlagName, featureFlagValue) {
-    if (this.canSendFeatureFlagsToTelemetry(featureFlagName, featureFlagValue)) {
-      VegaTelemetryRuntimeMetricsManager.emit('featureFlagOverridden', {
-        featureFlagName: featureFlagName,
-        featureFlagOverriddenValue: featureFlagValue,
-      });
-    }
-  }
-  /**
-   * The function `canSendFeatureFlagsToTelemetry` checks if a specific feature flag can be sent to
-   * telemetry based on certain conditions.
-   *
-   * @param {FeatureFlagKey} featureFlagName - The `featureFlagName` parameter represents the key or
-   * identifier of a feature flag. It is used to look up the corresponding feature flag in the
-   * `FeatureFlagsMap` object.
-   * @param {boolean} featureFlagValue - The `featureFlagValue` parameter in the
-   * `canSendFeatureFlagsToTelemetry` function represents the value of a specific feature flag. It is a
-   * boolean value that indicates whether the feature flag is enabled (`true`) or disabled (`false`).
-   * @returns {boolean} The function `canSendFeatureFlagsToTelemetry` is returning a boolean value.
-   */
-  canSendFeatureFlagsToTelemetry(featureFlagName, featureFlagValue) {
-    return !!FeatureFlagsMap[featureFlagName].disabledByDefault === featureFlagValue;
-  }
-}
-export const FeatureFlag = new FeatureFlagController();

package/dist/collection/helpers/feature-control/tests/featureFlagController.test.js

@@ -1,69 +0,0 @@
-jest.mock('../featureFlagsMap', () => {
-  return {
-    /* eslint-disable-next-line @typescript-eslint/naming-convention */
-    __esModule: true,
-    default: {
-      NOT_DEFAULT_DISABLED: {
-        description: ``,
-        createdTimestamp: 1681171200000,
-        createdAtVersion: '1.27.3',
-      },
-      DEFAULLT_DISABLED: {
-        description: ``,
-        createdTimestamp: 1679450185124,
-        createdAtVersion: '1.25.0',
-        disabledByDefault: true,
-      },
-      REMOVED_FEATURE_FLAG: {
-        description: ``,
-        createdTimestamp: 1679450185124,
-        createdAtVersion: '1.25.0',
-        removedAfterVersion: '1.38.2',
-      },
-    },
-  };
-});
-import { FeatureFlag } from '../featureFlagController';
-import VegaTelemetryRuntimeMetricsManager from '@globalpayments/vega-telemetry-runtime-metrics/runtime-metrics/src/index';
-const TEST_FLAG = 'NOT_DEFAULT_DISABLED';
-describe('featureFlagController unit test', () => {
-  it('should be set default disabled key', () => {
-    expect(Array.from(FeatureFlag['enabledFeatureFlagKeySet'])).toEqual(['NOT_DEFAULT_DISABLED']);
-    FeatureFlag.enable('DEFAULLT_DISABLED');
-    expect(Array.from(FeatureFlag['enabledFeatureFlagKeySet'])).toEqual([
-      'NOT_DEFAULT_DISABLED',
-      'DEFAULLT_DISABLED',
-    ]);
-  });
-  it('should be able to disable feature flag', () => {
-    expect(FeatureFlag.isEnabled(TEST_FLAG)).toBeTruthy();
-    FeatureFlag.disable(TEST_FLAG);
-    expect(FeatureFlag.isEnabled(TEST_FLAG)).toBeFalsy();
-  });
-  it('should be able to enable feature flag', () => {
-    FeatureFlag.disable(TEST_FLAG);
-    expect(FeatureFlag.isEnabled(TEST_FLAG)).toBeFalsy();
-    FeatureFlag.enable(TEST_FLAG);
-    expect(FeatureFlag.isEnabled(TEST_FLAG)).toBeTruthy();
-  });
-  it('should be able to check if feature flag is enabled', () => {
-    expect(FeatureFlag.isEnabled(TEST_FLAG)).toBeTruthy();
-    FeatureFlag.disable(TEST_FLAG);
-    expect(FeatureFlag.isEnabled(TEST_FLAG)).toBeFalsy();
-  });
-  it('should console error when enable or disabled removed feature flag key', async () => {
-    spyOn(console, 'error');
-    FeatureFlag.enable('REMOVED_FEATURE_FLAG');
-    expect(console.error).toHaveBeenCalledWith('%c[Vega]', 'font-weight: bold', "The feature flag key 'REMOVED_FEATURE_FLAG' has been removed after v1.38.2");
-    FeatureFlag.disable('REMOVED_FEATURE_FLAG');
-    expect(console.error).toHaveBeenCalledWith('%c[Vega]', 'font-weight: bold', "The feature flag key 'REMOVED_FEATURE_FLAG' has been removed after v1.38.2");
-  });
-  it('should send feature flag key to telemetry when enable or disabled feature flag key', async () => {
-    jest.spyOn(VegaTelemetryRuntimeMetricsManager, 'emit');
-    FeatureFlag.disable('NOT_DEFAULT_DISABLED');
-    expect(VegaTelemetryRuntimeMetricsManager.emit).toHaveBeenCalledWith('featureFlagOverridden', {
-      featureFlagName: 'NOT_DEFAULT_DISABLED',
-      featureFlagOverriddenValue: false,
-    });
-  });
-});

package/dist/collection/helpers/formatter/responsive-map-formatter/responsiveBorderRadiusFormatter.js

@@ -1,56 +0,0 @@
-import { isBreakpointsForPrefixType, isBorderRadiusTokenType, isDirectionalBorderRadiusType, } from '../../../types/typeGuard';
-import { LogUtility } from '../../../utils/log';
-import { ResponsiveClassStringFormatter } from './responsiveClassStringFormatter';
-import { BorderRadius } from '../../../constants/publicApi';
-const BORDER_RADIUS_DIRECTION_CLASS_PARTIAL_MAP = {
-  'top': 't',
-  'right': 'r',
-  'bottom': 'b',
-  'left': 'l',
-  'top-left': 'tl',
-  'top-right': 'tr',
-  'bottom-left': 'bl',
-  'bottom-right': 'br',
-};
-/**
- * A class for format BorderRadiusType with BreakpointsForPrefixType to CSS class string
- *
- * @augments ResponsiveClassStringFormatter
- */
-class ResponsiveBorderRadiusFormatter extends ResponsiveClassStringFormatter {
-  /**
-   * 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
-   * @param {BreakpointsForPrefixType} [breakpoint] - Breakpoints for prefix of the class
-   * @returns {string} - A string of CSS classes.
-   */
-  formatToken(input, breakpoint) {
-    const prefix = isBreakpointsForPrefixType(breakpoint) ? `${breakpoint}:` : '';
-    if (isBorderRadiusTokenType(input)) {
-      return `${prefix}v-${this.transformRoundedNoneAndFill(input)}`;
-    }
-    else if (isDirectionalBorderRadiusType(input)) {
-      return Object.keys(input)
-        .map((direction) => {
-        return `${prefix}v-rounded-${BORDER_RADIUS_DIRECTION_CLASS_PARTIAL_MAP[direction]}-${this.transformRoundedNoneAndFill(input[direction]).replace('rounded-', '')}`;
-      })
-        .join(' ');
-    }
-    else {
-      LogUtility.warn(`The border radius value ${input} is invalid, it must be a value of: `, BorderRadius);
-      return '';
-    }
-  }
-  /**
-   * The function `transformRoundedNoneAndFill` replaces 'rounded-none' with 'rounded-0' and
-   * 'rounded-full' with 'rounded-9999'.
-   *
-   * @param {string} rounded - The `rounded` parameter is a string that represents a CSS class related to the rounding of elements
-   * @returns {string} The transformed value .
-   */
-  transformRoundedNoneAndFill(rounded) {
-    return rounded.replace('rounded-none', 'rounded-0').replace('rounded-full', 'rounded-9999');
-  }
-}
-export default new ResponsiveBorderRadiusFormatter();

package/dist/collection/helpers/formatter/responsive-map-formatter/responsiveBoxDisplayFormatter.js

@@ -1,32 +0,0 @@
-import { isBreakpointsForPrefixType, isBoxDisplayType } from '../../../types/typeGuard';
-import { LogUtility } from '../../../utils/log';
-import { ResponsiveClassStringFormatter } from './responsiveClassStringFormatter';
-import { BoxDisplay } from '../../../constants/ui';
-/**
- * A class for format BoxDisplayType with BreakpointsForPrefixType to CSS class string
- *
- * @augments ResponsiveClassStringFormatter
- */
-class ResponsiveBoxDisplayFormatter extends ResponsiveClassStringFormatter {
-  /**
-   * The `formatToken` function takes an input value and an optional breakpoint value, and returns a formatted string based on the input value.
-   *
-   * @param {BoxDisplayType} input - The `input` parameter is of type `BoxDisplayType`. It represents the display value for a box element.
-   * @param {BreakpointsForPrefixType} [breakpoint] - The `breakpoint` parameter is an optional parameter of type `BreakpointsForPrefixType`. It is used to specify a breakpoint value for the prefix.
-   * @returns {string} a string value.
-   */
-  formatToken(input, breakpoint) {
-    const prefix = isBreakpointsForPrefixType(breakpoint) ? `${breakpoint}:` : '';
-    if (isBoxDisplayType(input)) {
-      if (input == 'none') {
-        return `${prefix}v-hidden`;
-      }
-      return `${prefix}v-${input}`;
-    }
-    else {
-      LogUtility.warn(`The box display value ${input} is invalid, it must be a value of: `, BoxDisplay);
-      return '';
-    }
-  }
-}
-export default new ResponsiveBoxDisplayFormatter();

package/dist/collection/helpers/formatter/responsive-map-formatter/responsiveClassStringFormatter.js

@@ -1,27 +0,0 @@
-import { isResponsiveType } from '../../../types/typeGuard';
-/**
- * An abstract class for format {@link ManagedResponsiveScopeInput[Flag]} to CSS class string
- */
-export class ResponsiveClassStringFormatter {
-  /**
-   * > 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 class string.
-   */
-  format(input) {
-    if (isResponsiveType(input)) {
-      return Object.keys(input)
-        .map((breakpoint) => {
-        const breakpointValue = input[breakpoint];
-        const breakPointFormatted = breakpoint !== 'default' ? breakpoint : undefined;
-        return this.formatToken(breakpointValue, breakPointFormatted);
-      })
-        .join(' ');
-    }
-    else {
-      return this.formatToken(input);
-    }
-  }
-}

package/dist/collection/helpers/formatter/responsive-map-formatter/responsiveCustomFormatter.js

@@ -1,28 +0,0 @@
-import { isResponsiveType } from '../../../types/typeGuard';
-import { getCurrentBreakpoint, createCompleteResponsiveMap } from '../../../utils/breakpoints';
-/**
- * A class for format Custom types
- *
- * @augments ResponsiveCustomFormatter
- */
-export class ResponsiveCustomFormatter {
-  /**
-   * If the input is not a responsive type, return it. If it is a responsive type, return the value for
-   * the current breakpoint
-   *
-   * @typedef T generic type parameter
-   * @param {ResponsiveType<T>} input - ResponsiveType<T>
-   * @returns {T} The value of the current breakpoint.
-   */
-  format(input) {
-    const breakpoint = getCurrentBreakpoint();
-    if (isResponsiveType(input)) {
-      input = createCompleteResponsiveMap(input);
-      return input[breakpoint];
-    }
-    else {
-      return input;
-    }
-  }
-}
-export default new ResponsiveCustomFormatter();

package/dist/collection/helpers/formatter/responsive-map-formatter/responsiveDisplayFormatter.js

@@ -1,31 +0,0 @@
-import { isBreakpointsForPrefixType } from '../../../types/typeGuard';
-import { LogUtility } from '../../../utils/log';
-import { ResponsiveClassStringFormatter } from './responsiveClassStringFormatter';
-/**
- * A class for format display with BreakpointsForPrefixType to CSS class string
- *
- * @augments ResponsiveClassStringFormatter
- */
-class ResponsiveDisplayFormatter extends ResponsiveClassStringFormatter {
-  /**
-   * Given a margin type, return a string of CSS classes that can be used to apply the margin to an element
-   *
-   * @param {boolean} input - display or not
-   * @param {BreakpointsForPrefixType} [breakpoint] - Breakpoints for prefix of the class
-   * @returns {string} - A string of CSS classes.
-   */
-  formatToken(input, breakpoint) {
-    const prefix = isBreakpointsForPrefixType(breakpoint) ? `${breakpoint}:` : '';
-    if ((typeof input === 'string' && input === 'false') || input === false) {
-      return `${prefix}v-hidden`;
-    }
-    else if ((typeof input === 'string' && input === 'true') || input === true) {
-      return `${prefix}v-block`;
-    }
-    else {
-      LogUtility.warn(`The display value ${input} is invalid, it must be a boolean`);
-      return '';
-    }
-  }
-}
-export default new ResponsiveDisplayFormatter();