@globalpayments/vega 2.18.1 → 2.20.0

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

@@ -1,97 +0,0 @@
-import { VegaButtonClickStrategy } from './vegaButtonClickStrategy';
-import { VegaCheckboxChangeStrategy } from './vegaCheckboxChangeStrategy';
-import { VegaInputSelectChangeStrategy } from './vegaInputSelectChangeStrategy';
-import { VegaInputStrategy } from './vegaInputStrategy';
-import { VegaRadioChangeStrategy } from './vegaRadioChangeStrategy';
-import { VegaTextareaChangeStrategy } from './vegaTextareaChangeStrategy';
-/** The `JQueryDelegatedStrategyController` class manages delegated event strategies for different HTML elements in a TypeScript application. */
-class JQueryDelegatedStrategyController {
-  /**
-   * The constructor initializes a registry of update strategies for various input events in a Vega application.
-   */
-  constructor() {
-    this.strategyRegistry = new Map();
-    this.updateStrategyRegistry([
-      new VegaButtonClickStrategy(),
-      new VegaInputStrategy('change'),
-      new VegaInputStrategy('focus'),
-      new VegaInputStrategy('blur'),
-      new VegaInputSelectChangeStrategy(),
-      new VegaTextareaChangeStrategy(),
-      new VegaCheckboxChangeStrategy(),
-      new VegaRadioChangeStrategy(),
-    ]);
-  }
-  /**
-   * The function checks if a given event on a specific HTML element is supported for delegation.
-   *
-   * @param {HTMLElement} host - The `host` parameter is an HTMLElement, which represents the element on which the event listener is attached.
-   * @param {VegaEventID} eventId - The `eventName` parameter is a string that represents the name of the event.
-   * @returns {boolean} a boolean value.
-   */
-  isSupportDelegated(host, eventId) {
-    let result = false;
-    const componentName = host.tagName.toLowerCase();
-    if (!!this.strategyRegistry.get(componentName) &&
-      !!this.strategyRegistry.get(componentName).get(eventId.getNativeName())) {
-      result = true;
-    }
-    return result;
-  }
-  /**
-   * The function updates the strategy registry with custom strategies based on the event semantics configuration.
-   *
-   * @param {EventSemanticsConfig} eventSemantics - The parameter `eventSemantics` is of type `EventSemanticsConfig`. It is an object that contains two properties: `global` and `components`.
-   */
-  updateRegistryFromEventSemantics(eventSemantics) {
-    let customStrategies = [];
-    const { global, components } = eventSemantics;
-    if (global && Array.isArray(global.jqueryDelegatedEvent)) {
-      customStrategies = customStrategies.concat(global.jqueryDelegatedEvent);
-    }
-    if (components) {
-      for (const name in components) {
-        if (Array.isArray(components[name].jqueryDelegatedEvent)) {
-          customStrategies = customStrategies.concat(components[name].jqueryDelegatedEvent);
-        }
-      }
-    }
-    if (customStrategies.length) {
-      this.updateStrategyRegistry(customStrategies);
-    }
-  }
-  /**
-   * The function returns a delegated event strategy based on the host element and event name.
-   *
-   * @param {HTMLElement} host - The `host` parameter is an HTMLElement that represents the element on
-   * which the event strategy is being applied. It is the element to which the event listener is attached.
-   * @param {VegaEventID} eventId - The `eventName` parameter is a string that represents the name of the event for which you want to retrieve the strategy.
-   * @returns {Nullable<JQueryDelegatedEventStrategy>} a Nullable<JQueryDelegatedEventStrategy>.
-   */
-  getStrategy(host, eventId) {
-    const componentName = host.tagName.toLowerCase();
-    if (this.strategyRegistry && this.strategyRegistry.get(componentName)) {
-      return this.strategyRegistry.get(componentName).get(eventId.getNativeName());
-    }
-  }
-  /**
-   * The function `overrideCurrentStrategy` updates the strategy registry with a new strategy for a specific host and event.
-   *
-   * @param {JQueryDelegatedEventStrategy[]} strategies - The parameter "strategy" is of type "JQueryDelegatedEventStrategy".
-   */
-  updateStrategyRegistry(strategies) {
-    strategies.forEach((strategy) => {
-      const hostName = strategy.getHostName();
-      const eventName = strategy.getEventName();
-      if (!this.strategyRegistry.get(hostName)) {
-        const map = new Map();
-        map.set(eventName, strategy);
-        this.strategyRegistry.set(hostName, map);
-      }
-      else {
-        this.strategyRegistry.get(hostName).set(eventName, strategy);
-      }
-    });
-  }
-}
-export default new JQueryDelegatedStrategyController();

package/dist/collection/helpers/event-manager/event-delegated/vegaButtonClickStrategy.js

@@ -1,23 +0,0 @@
-import { BaseStrategy } from './baseStrategy';
-/** The VegaButtonClickStrategy class is responsible for creating a button element when a click event is triggered on a VegaButton component. */
-export class VegaButtonClickStrategy extends BaseStrategy {
-  constructor() {
-    super(...arguments);
-    this.eventName = 'click';
-    this.vegaComponentName = 'vega-button';
-  }
-  /**
-   * The function creates a new HTML button element based on the properties of a delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is of type
-   * HTMLVegaButtonElement, which is a custom element that extends the HTMLButtonElement. It represents
-   * the target button element that will be delegated to create a new button element.
-   * @returns {HTMLButtonElement} an HTMLButtonElement.
-   */
-  createEventTarget(delegatedTarget) {
-    const button = document.createElement('button');
-    this.copyAttributesToTarget(delegatedTarget, button);
-    button.type = delegatedTarget.type;
-    return button;
-  }
-}

package/dist/collection/helpers/event-manager/event-delegated/vegaCheckboxChangeStrategy.js

@@ -1,23 +0,0 @@
-import { BaseStrategy } from './baseStrategy';
-/** The VegaCheckboxChangeStrategy class is responsible for creating an event target and handling the change event for Vega checkboxes. */
-export class VegaCheckboxChangeStrategy extends BaseStrategy {
-  constructor() {
-    super(...arguments);
-    this.eventName = 'change';
-    this.vegaComponentName = 'vega-checkbox';
-  }
-  /**
-   * The function creates and returns a checkbox input element with the same name as the given delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is of type
-   * HTMLVegaCheckboxElement, which is a custom element representing a checkbox component in the Vega UI framework.
-   * @returns {HTMLInputElement} an HTMLInputElement.
-   */
-  createEventTarget(delegatedTarget) {
-    const input = document.createElement('input');
-    this.copyAttributesToTarget(delegatedTarget, input);
-    input.type = 'checkbox';
-    input.checked = delegatedTarget.checked;
-    return input;
-  }
-}

package/dist/collection/helpers/event-manager/event-delegated/vegaInputSelectChangeStrategy.js

@@ -1,24 +0,0 @@
-import { BaseStrategy } from './baseStrategy';
-/** The VegaInputSelectChangeStrategy class is a TypeScript class that extends the BaseStrategy class and is used for handling the 'change' event for Vega input select components. */
-export class VegaInputSelectChangeStrategy extends BaseStrategy {
-  constructor() {
-    super(...arguments);
-    this.eventName = 'change';
-    this.vegaComponentName = 'vega-input-select';
-  }
-  /**
-   * The function creates a new HTML select element and sets its name attribute based on the name attribute of the delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is of type
-   * HTMLVegaInputSelectElement, which is a custom element that represents an input select element in the Vega framework.
-   * @returns {HTMLSelectElement} an HTMLSelectElement.
-   */
-  createEventTarget(delegatedTarget) {
-    const select = document.createElement('select');
-    this.copyAttributesToTarget(delegatedTarget, select);
-    if (delegatedTarget.value) {
-      select.value = delegatedTarget.value.toString();
-    }
-    return select;
-  }
-}

package/dist/collection/helpers/event-manager/event-delegated/vegaInputStrategy.js

@@ -1,30 +0,0 @@
-import { BaseStrategy } from './baseStrategy';
-/** The VegaInputBlurStrategy class is responsible for creating an input element when a blur event is triggered on a VegaInput component. */
-export class VegaInputStrategy extends BaseStrategy {
-  /**
-   * The constructor function initializes an instance of a class with a given eventName.
-   *
-   * @param {VegaNativeEventNameType} eventName - The eventName parameter is a string that represents the name of the event.
-   */
-  constructor(eventName) {
-    super();
-    this.vegaComponentName = 'vega-input';
-    this.eventName = eventName;
-  }
-  /**
-   * The function creates a new HTML input element with the same type as the provided delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is an
-   * HTMLVegaInputElement, which is a custom type or interface that represents an input element in the
-   * Vega framework. It likely has properties and methods specific to the Vega framework that are not
-   * present in the standard HTMLInputElement.
-   * @returns {HTMLInputElement} an HTMLInputElement.
-   */
-  createEventTarget(delegatedTarget) {
-    const input = document.createElement('input');
-    this.copyAttributesToTarget(delegatedTarget, input);
-    input.type = delegatedTarget.type;
-    input.value = delegatedTarget.value;
-    return input;
-  }
-}

package/dist/collection/helpers/event-manager/event-delegated/vegaRadioChangeStrategy.js

@@ -1,23 +0,0 @@
-import { BaseStrategy } from './baseStrategy';
-/** The VegaRadioChangeStrategy class is responsible for creating an input element for radio buttons and handling the 'change' event. */
-export class VegaRadioChangeStrategy extends BaseStrategy {
-  constructor() {
-    super(...arguments);
-    this.eventName = 'change';
-    this.vegaComponentName = 'vega-radio';
-  }
-  /**
-   * The function creates and returns a radio input element with the same name as the given delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is an
-   * HTMLVegaRadioElement, which is a custom element that represents a radio button in the Vega UI framework.
-   * @returns {HTMLInputElement} an HTMLInputElement.
-   */
-  createEventTarget(delegatedTarget) {
-    const input = document.createElement('input');
-    this.copyAttributesToTarget(delegatedTarget, input);
-    input.type = 'radio';
-    input.checked = delegatedTarget.checked;
-    return input;
-  }
-}

package/dist/collection/helpers/event-manager/event-delegated/vegaTextareaChangeStrategy.js

@@ -1,21 +0,0 @@
-import { BaseStrategy } from './baseStrategy';
-/** The VegaTextareaChangeStrategy class is a TypeScript class that extends the BaseStrategy class and is used for handling the 'change' event for a VegaTextarea component. */
-export class VegaTextareaChangeStrategy extends BaseStrategy {
-  constructor() {
-    super(...arguments);
-    this.vegaComponentName = 'vega-textarea';
-    this.eventName = 'change';
-  }
-  /**
-   * The function creates a textarea element and sets its name attribute based on the name attribute of a delegated target element.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is an HTMLVegaTextElement, which is an element that represents a text input field in the Vega visualization library.
-   * @returns {HTMLTextAreaElement} an HTMLTextAreaElement.
-   */
-  createEventTarget(delegatedTarget) {
-    const textarea = document.createElement('textarea');
-    this.copyAttributesToTarget(delegatedTarget, textarea);
-    textarea.value = delegatedTarget.value;
-    return textarea;
-  }
-}

package/dist/collection/helpers/event-manager/eventID/componentEventIdMap.js

@@ -1,55 +0,0 @@
-import { VegaExpand, VegaClick, VegaDropdownClick, VegaClose, VegaActionButtonClick, VegaChange, VegaEventClick, VegaDateDblClick, VegaPageUpdate, VegaCreate, VegaSearch, VegaDropdownShow, VegaDropdownHide, VegaDropdownSearch, VegaFormSubmit, VegaFormReset, VegaValidate, VegaRemove, VegaCancel, VegaFocus, VegaBlur, VegaCountryChange, VegaToggleStatus, VegaOpen, VegaStateUpdate, VegaGroupClick, VegaMenuClick, VegaActionClick, VegaPageSizeChange, VegaPopoverShow, VegaPopoverHide, VegaCurrentStepUpdate, VegaSelectChange, VegaSelectAllChange, VegaRowClick, } from './vegaEventId';
-const entries = [
-  ['vega-accordion', [VegaExpand]],
-  ['vega-app-header-button', [VegaClick, VegaDropdownClick]],
-  ['vega-banner', [VegaClose, VegaActionButtonClick]],
-  ['vega-breadcrumb', [VegaClick]],
-  ['vega-button', [VegaClick]],
-  ['vega-button-circle', [VegaClick]],
-  ['vega-button-group', [VegaClick]],
-  ['vega-button-link', [VegaClick]],
-  ['vega-calendar', [VegaChange, VegaEventClick, VegaDateDblClick]],
-  ['vega-carousel', [VegaPageUpdate]],
-  ['vega-checkbox', [VegaChange]],
-  ['vega-checkbox-group', [VegaChange]],
-  ['vega-chip', [VegaClose, VegaClick]],
-  ['vega-color-picker', [VegaChange]],
-  ['vega-combo-box', [VegaChange, VegaCreate, VegaSearch]],
-  ['vega-date-picker', [VegaChange]],
-  [
-    'vega-dropdown',
-    [VegaDropdownShow, VegaDropdownHide, VegaDropdownClick, VegaCreate, VegaDropdownSearch],
-  ],
-  ['vega-dropdown-item', [VegaClick]],
-  ['vega-field-label', [VegaClick]],
-  ['vega-form', [VegaFormSubmit, VegaFormReset, VegaValidate]],
-  ['vega-image-uploader', [VegaChange, VegaRemove, VegaCancel]],
-  ['vega-input', [VegaChange, VegaFocus, VegaBlur]],
-  ['vega-input-credit-card', [VegaChange, VegaBlur, VegaFocus]],
-  ['vega-input-phone-number', [VegaChange, VegaCountryChange]],
-  ['vega-input-range', [VegaChange]],
-  ['vega-input-select', [VegaChange, VegaSearch]],
-  ['vega-item-toggle', [VegaToggleStatus]],
-  ['vega-modal', [VegaOpen, VegaClose]],
-  ['vega-left-nav', [VegaStateUpdate]],
-  ['vega-left-nav-group', [VegaGroupClick]],
-  ['vega-left-nav-link', [VegaMenuClick]],
-  ['vega-left-nav-section', [VegaActionClick]],
-  ['vega-pagination', [VegaChange, VegaPageSizeChange]],
-  ['vega-popover', [VegaPopoverShow, VegaPopoverHide]],
-  ['vega-progress-tracker', [VegaCurrentStepUpdate]],
-  ['vega-radio', [VegaChange, VegaFocus, VegaBlur]],
-  ['vega-radio-group', [VegaChange]],
-  ['vega-segment-control', [VegaChange]],
-  ['vega-selection-tile', [VegaChange]],
-  ['vega-selection-tile-group', [VegaChange]],
-  ['vega-stepper', [VegaChange]],
-  ['vega-tab-group', [VegaClick]],
-  ['vega-table', [VegaChange, VegaSelectChange, VegaSelectAllChange, VegaRowClick]],
-  ['vega-table-head-cell', [VegaClick]],
-  ['vega-table-row', [VegaClick]],
-  ['vega-textarea', [VegaChange, VegaBlur]],
-  ['vega-time-picker', [VegaChange]],
-  ['vega-toggle-switch', [VegaChange]],
-];
-export const VEGA_COMPONENT_EVENT_MAP = new Map(entries);

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

@@ -1,92 +0,0 @@
-/** The VegaEventID class represents an event ID with both a Vega name and a native name. */
-export class VegaEventID {
-  /**
-   * The constructor function takes two parameters, vegaName and nativeName, and assigns them to private properties of the same names.
-   *
-   * @param {string} vegaName - The vegaName parameter is a private property of type string. It is used to store the name of a star in the Vega system.
-   * @param {VegaNativeEventNameType} nativeName - The `nativeName` parameter is a string that represents the name of the object in its native language or format.
-   */
-  constructor(vegaName, nativeName) {
-    this.vegaName = vegaName;
-    this.nativeName = nativeName;
-  }
-  /**
-   * The function `getName` returns the name of an object using the `getVegaName` method.
-   *
-   * @returns {string} The `getName` method is returning the result of calling the `getVegaName` method.
-   */
-  getName() {
-    return this.getVegaName();
-  }
-  /**
-   * use the Event Name Manager API to determined to return the vega name of the native name
-   *
-   * @param {EventSemantics} eventSemantics object define namespace and jqueryDelegatedEvent properties
-   * @returns {string} The method is returning the value of the variable "vegaName" or "nativeName" as a string.
-   */
-  getCurrentName(eventSemantics) {
-    return eventSemantics.namespace !== 'native' ? this.getVegaName() : this.getNativeName();
-  }
-  /**
-   * The function returns the value of the variable "vegaName" as a string.
-   *
-   * @returns {string} The method is returning the value of the variable "vegaName" as a string.
-   */
-  getVegaName() {
-    return this.vegaName;
-  }
-  /**
-   * The function returns the value of the variable "nativeName" as a string.
-   *
-   * @returns {string} The method is returning the value of the variable "nativeName" as a string.
-   */
-  getNativeName() {
-    return this.nativeName;
-  }
-  /**
-   * The function checks if the current event is a raw event in a browser environment.
-   *
-   * @returns {boolean} a boolean value.
-   */
-  isBrowserRawEvent() {
-    return HTMLNativeEventIds.includes(this);
-  }
-}
-export const VegaChange = new VegaEventID('vegaChange', 'change');
-export const VegaClick = new VegaEventID('vegaClick', 'click');
-export const VegaFocus = new VegaEventID('vegaFocus', 'focus');
-export const VegaBlur = new VegaEventID('vegaBlur', 'blur');
-export const VegaClose = new VegaEventID('vegaClose', 'close');
-export const VegaOpen = new VegaEventID('vegaOpen', 'modalOpen');
-export const VegaValidate = new VegaEventID('vegaValidate', 'validate');
-export const VegaFormSubmit = new VegaEventID('vegaFormSubmit', 'formSubmit');
-export const VegaFormReset = new VegaEventID('vegaFormReset', 'formReset');
-export const VegaRowClick = new VegaEventID('vegaRowClick', 'rowClick');
-export const VegaSelectChange = new VegaEventID('vegaSelectChange', 'selectChange');
-export const VegaSelectAllChange = new VegaEventID('vegaSelectAllChange', 'selectAllChange');
-export const VegaPageSizeChange = new VegaEventID('vegaPageSizeChange', 'pageSizeChange');
-export const VegaDropdownClick = new VegaEventID('vegaDropdownClick', 'dropdownClick');
-export const VegaCreate = new VegaEventID('vegaCreate', 'create');
-export const VegaSearch = new VegaEventID('vegaSearch', 'search');
-export const VegaHide = new VegaEventID('vegaHide', 'hide');
-export const VegaShow = new VegaEventID('vegaShow', 'show');
-export const VegaPopoverShow = new VegaEventID('vegaPopoverShow', 'popoverShow');
-export const VegaPopoverHide = new VegaEventID('vegaPopoverHide', 'popoverHide');
-export const VegaCancel = new VegaEventID('vegaCancel', 'cancel');
-export const VegaRemove = new VegaEventID('vegaRemove', 'remove');
-export const VegaPageUpdate = new VegaEventID('vegaPageUpdate', 'pageUpdate');
-export const VegaCurrentStepUpdate = new VegaEventID('vegaCurrentStepUpdate', 'currentStepUpdate');
-export const VegaToggleStatus = new VegaEventID('vegaToggleStatus', 'toggleStatus');
-export const VegaStateUpdate = new VegaEventID('vegaStateUpdate', 'stateUpdate');
-export const VegaGroupClick = new VegaEventID('vegaGroupClick', 'groupClick');
-export const VegaMenuClick = new VegaEventID('vegaMenuClick', 'menuClick');
-export const VegaExpand = new VegaEventID('vegaExpand', 'accordionExpand');
-export const VegaDropdownShow = new VegaEventID('vegaShow', 'dropdownShow');
-export const VegaDropdownHide = new VegaEventID('vegaHide', 'dropdownHide');
-export const VegaDropdownSearch = new VegaEventID('vegaSearch', 'dropdownSearch');
-export const VegaActionClick = new VegaEventID('vegaActionClick', 'actionClick');
-export const VegaEventClick = new VegaEventID('vegaEventClick', 'eventClick');
-export const VegaDateDblClick = new VegaEventID('vegaDateDblClick', 'dateDblClick');
-export const VegaCountryChange = new VegaEventID('vegaCountryChange', 'countryChange');
-export const VegaActionButtonClick = new VegaEventID('vegaActionButtonClick', 'actionButtonClick');
-export const HTMLNativeEventIds = [VegaChange, VegaClick, VegaFocus, VegaBlur];

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

@@ -1,70 +0,0 @@
-import { VEGA_COMPONENT_EVENT_MAP } from './eventID/componentEventIdMap';
-import jqueryDelegatedStrategyController from './event-delegated/jqueryDelegatedStrategyController';
-/**
- * The `InternalVegaEventManager` class manages event semantics configuration for global and
- * component-specific settings.
- */
-class InternalVegaEventManager {
-  constructor() {
-    this.config = {};
-    this.defaultEventSemantics = {
-      namespace: 'vega',
-    };
-  }
-  /**
-   * The function sets the semantics configuration for events.
-   *
-   * @param {EventSemanticsConfig} config - The `config` parameter is of type `EventSemanticsConfig`.
-   */
-  setSemantics(config) {
-    this.config = config;
-    jqueryDelegatedStrategyController.updateRegistryFromEventSemantics(config);
-  }
-  /**
-   * The function `getSemantics` returns the event semantics either from the global scope or from the
-   * components within a given host element.
-   *
-   * @param {HTMLElement} host - The host parameter is an HTMLElement that represents the element on
-   * which the event semantics are being checked.
-   * @returns {EventSemantics} The method `getSemantics` returns a value of type `Nullable<EventSemantics>`.
-   */
-  getSemantics(host) {
-    return Object.assign({}, this.defaultEventSemantics, this.getSemanticsInGlobal(), this.getSemanticsInComponents(host));
-  }
-  /**
-   * The function "getEnabledEventIdsByComponent" returns an array of event Ids associated with a given component
-   * name.
-   *
-   * @param {VegaComponentName} componentName - The `componentName` parameter is a string that represents
-   * the name of a Vega component.
-   * @returns {Nullable<VegaEventID[]>} a nullable array of VegaEventID objects.
-   */
-  getEnabledEventIdsByComponent(componentName) {
-    return VEGA_COMPONENT_EVENT_MAP.get(componentName);
-  }
-  /**
-   * The function `getSemanticsInGlobal` returns the global event semantics configuration.
-   *
-   * @returns {EventSemantics} The method is returning a nullable EventSemantics object.
-   */
-  getSemanticsInGlobal() {
-    return this.config.global;
-  }
-  /**
-   * The function `getSemanticsInComponents` returns the semantic configuration for a given component
-   * based on its host element.
-   *
-   * @param {HTMLElement} host - The `host` parameter is an HTMLElement that represents the component for
-   * which we want to retrieve the semantics.
-   * @returns {Nullable<EventSemantics>} a value of type `Nullable<EventSemantics>`.
-   */
-  getSemanticsInComponents(host) {
-    const componentName = host.tagName.toLocaleLowerCase();
-    if (this.config.components &&
-      Object.prototype.hasOwnProperty.call(this.config.components, componentName)) {
-      return this.config.components[componentName];
-    }
-    return null;
-  }
-}
-export default new InternalVegaEventManager();

package/dist/collection/helpers/event-manager/slimmers/childNodesEventPreventSlimmer.js

@@ -1,155 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { MapToComponentField, MapToComponentMethod, VegaSlimmer } from 'vega-slimmer/core';
-import InternalVegaEventManager from '../internalVegaEventManager';
-import jqueryDelegatedStrategyController from '../event-delegated/jqueryDelegatedStrategyController';
-import internalVegaEventManager from '../internalVegaEventManager';
-import vegaEnvManager from '../../vega-telemetry-helper/vegaEnvManager';
-import { FeatureFlag } from '../../feature-control/featureFlagController';
-/** The ChildNodesEventPreventSlimmer class prevents specified events from propagating to parent elements. */
-export class ChildNodesEventPreventSlimmer extends VegaSlimmer {
-  /**
-   * The constructor function takes in an array of event names and a function to get the parent element, and assigns them to the corresponding properties of the class.
-   *
-   * @param {VegaEventID[]} eventIds - The eventNames parameter is an array of VegaEventID that represents the names of the events that will be handled by the constructor.
-   * @param {HTMLElement} getHostElement - The `getHostElement` parameter is a function that returns an `HTMLElement`. It is used to get the parent element where the events will be attached.
-   * @param {boolean | EventPreventOptions} options - add event listener in capture or bubbles.
-   * @param {boolean | EventPreventOptions} needSkipByDefault - should skip event prevent by default
-   */
-  constructor(eventIds, getHostElement, options, needSkipByDefault) {
-    super();
-    // the event names need prevent from child nodes
-    this.eventIds = [];
-    this.useCapture = false;
-    this.isEventListenerAdded = false;
-    this.disabled = false;
-    /**
-     * prevent the child event
-     *
-     * @param {CustomEvent} event event object
-     */
-    this.preventChildEvent = (event) => {
-      const hostElement = this.getHostElement();
-      if (this.shouldSkipEventPrevent()) {
-        return;
-      }
-      if (typeof this.customPreventHandle === 'function') {
-        this.customPreventHandle(event);
-      }
-      else {
-        const composed = event.composedPath();
-        if (hostElement !== event.target || hostElement !== composed[0]) {
-          event.stopImmediatePropagation();
-        }
-      }
-    };
-    this.eventIds = eventIds;
-    this.getHostElement = getHostElement;
-    if (options === true) {
-      this.useCapture = true;
-    }
-    else if (options) {
-      const { useCapture = false, customPreventHandle } = options;
-      this.useCapture = useCapture;
-      this.customPreventHandle = customPreventHandle;
-    }
-    this.disabled = needSkipByDefault === true ? true : false;
-  }
-  /**
-   * add event listener when component connected, we can call the method manually if the host element not ready when connectedCallback
-   */
-  setup() {
-    this.addOrRemoveEventListener('add');
-  }
-  /**
-   * if the host element ready after component did load, then add the event listener again.
-   */
-  checkEventListenerStatus() {
-    if (!this.isEventListenerAdded) {
-      this.setup();
-    }
-    this.setSkipEventPreventFlag();
-  }
-  /**
-   * remove the event listener when component disconnect
-   */
-  destroy() {
-    this.addOrRemoveEventListener('remove');
-  }
-  /**
-   * The function `setSkipEventPreventFlag` sets a flag on a host element to skip event prevention under certain conditions.
-   */
-  setSkipEventPreventFlag() {
-    if (FeatureFlag.isEnabled('VEGA_REACT.SKIP_NATIVE_EVENT_PREVENT_BY_DEFAULT') &&
-      this.disabled &&
-      this.host &&
-      vegaEnvManager.getVegaEnv().framework === 'react' &&
-      internalVegaEventManager.getSemantics(this.host).namespace === 'native') {
-      const el = this.getHostElement();
-      el.setAttribute('data-vega-no-event-prevent', 'true');
-    }
-  }
-  /**
-   * add or remove the event from the parent element
-   *
-   * @param {'add'|'remove'} actionType add or remove
-   */
-  addOrRemoveEventListener(actionType) {
-    const hostElement = this.getHostElement();
-    if (this.eventIds && this.eventIds.length && hostElement) {
-      this.eventIds
-        .filter((eventID) => this.shouldPrevent(eventID))
-        .forEach((eventID) => {
-        hostElement[actionType === 'add' ? 'addEventListener' : 'removeEventListener'](this.getCurrentEventName(eventID), this.preventChildEvent, this.useCapture);
-      });
-      this.isEventListenerAdded = actionType === 'add' ? true : false;
-    }
-  }
-  /**
-   * get the current event name
-   *
-   * @param {VegaEventID} eventId event id class
-   * @returns {string} native or vega event name string
-   */
-  getCurrentEventName(eventId) {
-    return eventId.getCurrentName(InternalVegaEventManager.getSemantics(this.host));
-  }
-  /**
-   * The function shouldPrevent checks if a given event ID should be prevented based on whether it is a
-   * native event and if it is enabled for the host.
-   *
-   * @param {VegaEventID} eventId - The `eventId` parameter is of type `VegaEventID`. It represents the ID of an event.
-   * @returns {boolean} a boolean value.
-   */
-  shouldPrevent(eventId) {
-    const { namespace, jqueryDelegatedEvent } = internalVegaEventManager.getSemantics(this.host);
-    return !(namespace === 'native' &&
-      !!jqueryDelegatedEvent &&
-      jqueryDelegatedStrategyController.isSupportDelegated(this.host, eventId));
-  }
-  /**
-   * The function `shouldSkipEventPrevent` checks if a host element has a specific dataset value to determine whether event prevention should be skipped.
-   *
-   * @returns {boolean} If the `hostElement` exists and has a `dataset.vegaNoEventPrevent` attribute with a value of `'true'`, then the function returns `true`. Otherwise, it returns `false`.
-   */
-  shouldSkipEventPrevent() {
-    const hostElement = this.getHostElement();
-    return hostElement && hostElement.dataset.vegaNoEventPrevent === 'true';
-  }
-}
-__decorate([
-  MapToComponentField()
-], ChildNodesEventPreventSlimmer.prototype, "host", void 0);
-__decorate([
-  MapToComponentMethod('connectedCallback')
-], ChildNodesEventPreventSlimmer.prototype, "setup", null);
-__decorate([
-  MapToComponentMethod('componentDidLoad')
-], ChildNodesEventPreventSlimmer.prototype, "checkEventListenerStatus", null);
-__decorate([
-  MapToComponentMethod('disconnectedCallback')
-], ChildNodesEventPreventSlimmer.prototype, "destroy", null);