@globalpayments/vega 2.13.0 → 2.50.0

package/dist/types/helpers/event-manager/event-delegated/jqueryDelegatedStrategyController.d.ts

@@ -1,44 +0,0 @@
-import { Nullable } from '../../../types/general';
-import { VegaEventID } from '../eventID/vegaEventId';
-import { EventSemanticsConfig } from '../internalVegaEventManager';
-import { JQueryDelegatedEventStrategy } from './jqueryDelegatedEventStrategy';
-export declare type DelegatedStrategyMapType = Map<string, JQueryDelegatedEventStrategy>;
-/** The `JQueryDelegatedStrategyController` class manages delegated event strategies for different HTML elements in a TypeScript application. */
-declare class JQueryDelegatedStrategyController {
-  private strategyRegistry;
-  /**
-   * The constructor initializes a registry of update strategies for various input events in a Vega application.
-   */
-  constructor();
-  /**
-   * 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: HTMLElement, eventId: VegaEventID): boolean;
-  /**
-   * 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: EventSemanticsConfig): void;
-  /**
-   * 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: HTMLElement, eventId: VegaEventID): Nullable<JQueryDelegatedEventStrategy>;
-  /**
-   * 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".
-   */
-  private updateStrategyRegistry;
-}
-declare const _default: JQueryDelegatedStrategyController;
-export default _default;

package/dist/types/helpers/event-manager/event-delegated/vegaButtonClickStrategy.d.ts

@@ -1,16 +0,0 @@
-import { VegaComponentName, VegaNativeEventNameType } from '../../../types/ui.type';
-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 declare class VegaButtonClickStrategy extends BaseStrategy {
-  eventName: VegaNativeEventNameType;
-  vegaComponentName: VegaComponentName;
-  /**
-   * 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: HTMLVegaButtonElement): HTMLButtonElement;
-}

package/dist/types/helpers/event-manager/event-delegated/vegaCheckboxChangeStrategy.d.ts

@@ -1,15 +0,0 @@
-import { VegaComponentName, VegaNativeEventNameType } from '../../../types/ui.type';
-import { BaseStrategy } from './baseStrategy';
-/** The VegaCheckboxChangeStrategy class is responsible for creating an event target and handling the change event for Vega checkboxes. */
-export declare class VegaCheckboxChangeStrategy extends BaseStrategy {
-  eventName: VegaNativeEventNameType;
-  vegaComponentName: VegaComponentName;
-  /**
-   * 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: HTMLVegaCheckboxElement): HTMLInputElement;
-}

package/dist/types/helpers/event-manager/event-delegated/vegaInputSelectChangeStrategy.d.ts

@@ -1,15 +0,0 @@
-import { VegaComponentName, VegaNativeEventNameType } from '../../../types/ui.type';
-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 declare class VegaInputSelectChangeStrategy extends BaseStrategy {
-  eventName: VegaNativeEventNameType;
-  vegaComponentName: VegaComponentName;
-  /**
-   * 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: HTMLVegaInputSelectElement): HTMLSelectElement;
-}

package/dist/types/helpers/event-manager/event-delegated/vegaInputStrategy.d.ts

@@ -1,23 +0,0 @@
-import { VegaComponentName, VegaNativeEventNameType } from '../../../types/ui.type';
-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 declare class VegaInputStrategy extends BaseStrategy {
-  eventName: VegaNativeEventNameType;
-  vegaComponentName: VegaComponentName;
-  /**
-   * 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: VegaNativeEventNameType);
-  /**
-   * 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: HTMLVegaInputElement): HTMLInputElement;
-}

package/dist/types/helpers/event-manager/event-delegated/vegaRadioChangeStrategy.d.ts

@@ -1,15 +0,0 @@
-import { VegaComponentName, VegaNativeEventNameType } from '../../../types/ui.type';
-import { BaseStrategy } from './baseStrategy';
-/** The VegaRadioChangeStrategy class is responsible for creating an input element for radio buttons and handling the 'change' event. */
-export declare class VegaRadioChangeStrategy extends BaseStrategy {
-  eventName: VegaNativeEventNameType;
-  vegaComponentName: VegaComponentName;
-  /**
-   * 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: HTMLVegaRadioElement): HTMLInputElement;
-}

package/dist/types/helpers/event-manager/event-delegated/vegaTextareaChangeStrategy.d.ts

@@ -1,14 +0,0 @@
-import { VegaComponentName, VegaNativeEventNameType } from '../../../types/ui.type';
-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 declare class VegaTextareaChangeStrategy extends BaseStrategy {
-  vegaComponentName: VegaComponentName;
-  eventName: VegaNativeEventNameType;
-  /**
-   * 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: HTMLVegaTextareaElement): HTMLTextAreaElement;
-}

package/dist/types/helpers/event-manager/eventID/componentEventIdMap.d.ts

@@ -1,3 +0,0 @@
-import { VegaComponentName } from '../../../types/ui.type';
-import { VegaEventID } from './vegaEventId';
-export declare const VEGA_COMPONENT_EVENT_MAP: Map<VegaComponentName, VegaEventID[]>;

package/dist/types/helpers/event-manager/eventID/vegaEventId.d.ts

@@ -1,80 +0,0 @@
-import { EventSemantics } from '../internalVegaEventManager';
-import { VegaNativeEventNameType } from '../../../types/ui.type';
-import { VegaEventIDInterface } from './vegaEventIdInterface';
-/** The VegaEventID class represents an event ID with both a Vega name and a native name. */
-export declare class VegaEventID implements VegaEventIDInterface {
-  private vegaName;
-  private nativeName;
-  /**
-   * 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: string, nativeName: VegaNativeEventNameType);
-  /**
-   * 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(): string;
-  /**
-   * 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: EventSemantics): string;
-  /**
-   * 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(): string;
-  /**
-   * 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(): string;
-  /**
-   * The function checks if the current event is a raw event in a browser environment.
-   *
-   * @returns {boolean} a boolean value.
-   */
-  isBrowserRawEvent(): boolean;
-}
-export declare const VegaChange: VegaEventID;
-export declare const VegaClick: VegaEventID;
-export declare const VegaFocus: VegaEventID;
-export declare const VegaBlur: VegaEventID;
-export declare const VegaClose: VegaEventID;
-export declare const VegaOpen: VegaEventID;
-export declare const VegaValidate: VegaEventID;
-export declare const VegaFormSubmit: VegaEventID;
-export declare const VegaFormReset: VegaEventID;
-export declare const VegaRowClick: VegaEventID;
-export declare const VegaSelectChange: VegaEventID;
-export declare const VegaSelectAllChange: VegaEventID;
-export declare const VegaPageSizeChange: VegaEventID;
-export declare const VegaDropdownClick: VegaEventID;
-export declare const VegaCreate: VegaEventID;
-export declare const VegaSearch: VegaEventID;
-export declare const VegaHide: VegaEventID;
-export declare const VegaShow: VegaEventID;
-export declare const VegaPopoverShow: VegaEventID;
-export declare const VegaPopoverHide: VegaEventID;
-export declare const VegaCancel: VegaEventID;
-export declare const VegaRemove: VegaEventID;
-export declare const VegaPageUpdate: VegaEventID;
-export declare const VegaCurrentStepUpdate: VegaEventID;
-export declare const VegaToggleStatus: VegaEventID;
-export declare const VegaStateUpdate: VegaEventID;
-export declare const VegaGroupClick: VegaEventID;
-export declare const VegaMenuClick: VegaEventID;
-export declare const VegaExpand: VegaEventID;
-export declare const VegaDropdownShow: VegaEventID;
-export declare const VegaDropdownHide: VegaEventID;
-export declare const VegaDropdownSearch: VegaEventID;
-export declare const VegaActionClick: VegaEventID;
-export declare const HTMLNativeEventIds: VegaEventID[];

package/dist/types/helpers/event-manager/eventID/vegaInternalEventId.d.ts

@@ -1,24 +0,0 @@
-import { VegaEventIDInterface } from './vegaEventIdInterface';
-/** The class VegaInternalEventID implements the VegaEventIDInterface and provides a method to get the current name. */
-export declare class VegaInternalEventID implements VegaEventIDInterface {
-  private name;
-  /**
-   * This TypeScript constructor function takes a string parameter and assigns it to a private property called "name".
-   *
-   * @param {string} name - It is used to initialize an instance of the class with a specific name value.
-   */
-  constructor(name: string);
-  /**
-   * This TypeScript function returns the name stored in the object.
-   *
-   * @returns {string} The `name` property of the current object is being returned as a string.
-   */
-  getName(): string;
-}
-export declare const VegaInternalValid: VegaInternalEventID;
-export declare const VegaInternalFieldErrorStateChange: VegaInternalEventID;
-export declare const VegaInternalVirtualScrollToBottom: VegaInternalEventID;
-export declare const VegaInternalButtonGroupClick: VegaInternalEventID;
-export declare const VegaInternalLeftNavLinkClick: VegaInternalEventID;
-export declare const VegaInternalSubStatePull: VegaInternalEventID;
-export declare const VegaInternalSubStatePush: VegaInternalEventID;

package/dist/types/helpers/event-manager/internalVegaEventManager.d.ts

@@ -1,63 +0,0 @@
-import { Nullable } from '../../types/general';
-import { VegaComponentName } from '../../types/ui.type';
-import { VegaEventID } from './eventID/vegaEventId';
-import { JQueryDelegatedEventStrategy } from './event-delegated/jqueryDelegatedEventStrategy';
-export declare type EventSemanticsConfig = {
-  global?: EventSemantics;
-  components?: {
-    [key in VegaComponentName]?: EventSemantics;
-  };
-};
-export declare type EventSemantics = {
-  namespace: 'vega' | 'native';
-  jqueryDelegatedEvent?: boolean | JQueryDelegatedEventStrategy[];
-};
-/**
- * The `InternalVegaEventManager` class manages event semantics configuration for global and
- * component-specific settings.
- */
-declare class InternalVegaEventManager {
-  private config;
-  private readonly defaultEventSemantics;
-  /**
-   * The function sets the semantics configuration for events.
-   *
-   * @param {EventSemanticsConfig} config - The `config` parameter is of type `EventSemanticsConfig`.
-   */
-  setSemantics(config: EventSemanticsConfig): void;
-  /**
-   * 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: HTMLElement): EventSemantics;
-  /**
-   * 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: VegaComponentName): Nullable<VegaEventID[]>;
-  /**
-   * The function `getSemanticsInGlobal` returns the global event semantics configuration.
-   *
-   * @returns {EventSemantics} The method is returning a nullable EventSemantics object.
-   */
-  private getSemanticsInGlobal;
-  /**
-   * 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>`.
-   */
-  private getSemanticsInComponents;
-}
-declare const _default: InternalVegaEventManager;
-export default _default;

package/dist/types/helpers/event-manager/slimmers/childNodesEventPreventSlimmer.d.ts

@@ -1,74 +0,0 @@
-import { VegaSlimmer } from '../../../vega-slimmer/vega-slimmer-core';
-import { VegaEventID } from '../eventID/vegaEventId';
-declare type EventPreventOptions = {
-  useCapture?: boolean;
-  customPreventHandle?: (e: Event) => void;
-};
-/** The ChildNodesEventPreventSlimmer class prevents specified events from propagating to parent elements. */
-export declare class ChildNodesEventPreventSlimmer extends VegaSlimmer {
-  protected host: HTMLElement;
-  private eventIds;
-  private useCapture;
-  private customPreventHandle;
-  /**
-   * the parent element of the child node, not the host of the component
-   *
-   * example: vega-checkbox-group
-   * <vega-checkbox-group>
-   *   <vega-flex>
-   *     <vega-checkbox/>
-   *     <vega-checkbox/>
-   * ...
-   * we need to prevent the event bubbles from vega-checkbox, the vega-flex could be a host element.
-   */
-  private getHostElement;
-  private isEventListenerAdded;
-  /**
-   * 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.
-   */
-  constructor(eventIds: VegaEventID[], getHostElement: () => HTMLElement, options?: boolean | EventPreventOptions);
-  /**
-   * add event listener when component connected, we can call the method manually if the host element not ready when connectedCallback
-   */
-  setup(): void;
-  /**
-   * if the host element ready after component did load, then add the event listener again.
-   */
-  checkEventListenerStatus(): void;
-  /**
-   * remove the event listener when component disconnect
-   */
-  destroy(): void;
-  /**
-   * add or remove the event from the parent element
-   *
-   * @param {'add'|'remove'} actionType add or remove
-   */
-  private addOrRemoveEventListener;
-  /**
-   * get the current event name
-   *
-   * @param {VegaEventID} eventId event id class
-   * @returns {string} native or vega event name string
-   */
-  private getCurrentEventName;
-  /**
-   * 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.
-   */
-  private shouldPrevent;
-  /**
-   * prevent the child event
-   *
-   * @param {CustomEvent} event event object
-   */
-  private preventChildEvent;
-}
-export {};

package/dist/types/helpers/event-manager/slimmers/childNodesNotifyObserverSlimmer.d.ts

@@ -1,47 +0,0 @@
-import { VegaSlimmer } from '../../../vega-slimmer/vega-slimmer-core';
-import { Subject } from '../../change-manager/subject/subjectInterface';
-export declare type NotifyObserverPayload<T> = {
-  host: HTMLElement;
-  detail: T;
-  eventName?: string;
-};
-export declare type NotifyObserverCallback = (input?: NotifyObserverPayload<unknown>) => void;
-export declare type CustomAcceptableType = (input?: NotifyObserverPayload<unknown>) => boolean;
-/** The `ChildNodesNotifyObserverSlimmer` class is a TypeScript class that acts as a slimmed-down version of a notify observer for child nodes, allowing for add and remove of observers and handling of observer payloads. */
-export declare class ChildNodesNotifyObserverSlimmer<T> extends VegaSlimmer {
-  host: HTMLElement;
-  private subject;
-  private callback;
-  private customAcceptableHandle;
-  private notifyObserver;
-  private acceptableResultMap;
-  /**
-   * Initialize the notify observer.
-   */
-  connectedCallback(): void;
-  /**
-   * Unregister the observer when disconnectedCallback
-   */
-  disconnectedCallback(): void;
-  /**
-   * The constructor function initializes the subject and notifyObserverEntry properties of the class.
-   *
-   * @param {Subject} subject - The `subject` parameter is an instance of the `Subject` class. It represents the subject that the observer will be observing.
-   * @param {NotifyObserverCallback} callback - It is typically called by the subject when it undergoes a change and needs to notify its observers.
-   * @param {CustomAcceptableType} [customAcceptableHandle] - It is typically called by the subject when it undergoes a change and needs to notify its observers.
-   */
-  constructor(subject: Subject, callback: NotifyObserverCallback, customAcceptableHandle?: CustomAcceptableType);
-  /**
-   * It is used to determine whether a given observer payload is acceptable for the observer.
-   *
-   * @param {NotifyObserverPayload<unknown>} input input payload
-   * @returns {boolean} true or false
-   */
-  private isAcceptableObserverPayload;
-  /**
-   * trigger the callback function
-   *
-   * @param {NotifyObserverPayload<unknown>} input input payload
-   */
-  private handleObserver;
-}

package/dist/types/helpers/event-manager/slimmers/event-emit-handlers/eventEmitHandler.d.ts

@@ -1,7 +0,0 @@
-import { Nullable } from '../../../../types/general';
-import { VegaEventID } from '../../eventID/vegaEventId';
-import { EventSemantics } from '../../internalVegaEventManager';
-export interface EventEmitHandler {
-  canHandle: (eventSemantics: EventSemantics, eventID?: VegaEventID) => boolean;
-  handle: <T>(detail: T, e?: Event) => Nullable<Event>;
-}

package/dist/types/helpers/event-manager/slimmers/event-emit-handlers/jqueryDelegatedEventEmitHandler.d.ts

@@ -1,33 +0,0 @@
-import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
-import { EventEmitHandler } from './eventEmitHandler';
-import { EventSemantics } from '../../internalVegaEventManager';
-import { VegaEventID } from '../../eventID/vegaEventId';
-import { Nullable } from '../../../../types/general';
-/** The `JqueryDelegatedEventEmitHandlerSlimmer` class is a TypeScript class that handles emitting delegated events using jQuery. */
-export declare class JqueryDelegatedEventEmitHandlerSlimmer extends VegaSlimmer implements EventEmitHandler {
-  protected host: HTMLElement;
-  private eventID;
-  /**
-   * The function "setEventID" sets the eventID property of the current object to the provided VegaEventID value.
-   *
-   * @param {VegaEventID} eventID - The eventID parameter is of type VegaEventID.
-   */
-  setEventID(eventID: VegaEventID): void;
-  /**
-   * The function determines whether a jQuery delegated event should be emitted based on certain conditions.
-   *
-   * @param {EventSemantics} namespace the event semantics namespace
-   * @returns {boolean} The function shouldEmitJqueryDelegatedEvent() returns a boolean value.
-   */
-  canHandle: ({ namespace, jqueryDelegatedEvent }: EventSemantics) => boolean;
-  /**
-   * The function emits a delegated event with a given detail using a jQuery delegated event slimmer.
-   *
-   * @param {unknown} detail - The `detail` parameter is a generic type `T` that represents additional
-   * information or data associated with the event. It can be any type of data that you want to pass
-   * along with the event when it is emitted.
-   * @param {Event} [e] the event object
-   * @returns {Nullable<Event>} The emitted event.
-   */
-  handle: <T>(detail: T, e?: Event) => Nullable<Event>;
-}

package/dist/types/helpers/event-manager/slimmers/event-emit-handlers/nativeEventEmitHandler.d.ts

@@ -1,25 +0,0 @@
-import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
-import { EventEmitHandler } from './eventEmitHandler';
-import { EventEmitter } from '../../../../stencil-public-runtime';
-import { EventSemantics } from '../../internalVegaEventManager';
-/** The `NativeEventEmitHandlerSlimmer` class is a TypeScript class that handles emitting native events based on event semantics. */
-export declare class NativeEventEmitHandlerSlimmer extends VegaSlimmer implements EventEmitHandler {
-  protected nativeEvent: EventEmitter;
-  /**
-   * The function determines whether a native event should be emitted based on the namespace of the event semantics.
-   *
-   * @param {EventSemantics} namespace the event semantics namespace
-   * @returns {boolean} a boolean value.
-   */
-  canHandle: ({ namespace }: EventSemantics) => boolean;
-  /**
-   * The function emits a native event with a given detail.
-   *
-   * @param {unknown} detail - The `detail` parameter is a generic type `T` that represents the data or
-   * information that you want to pass along with the event. It can be any type of data, such as a
-   * string, number, object, or custom type.
-   * @param {Event} [e] the event object
-   * @returns {CustomEvent} The emitted event.
-   */
-  handle: <T>(detail: T, e?: Event) => CustomEvent<T>;
-}

package/dist/types/helpers/event-manager/slimmers/event-emit-handlers/vegaEventEmitHandler.d.ts

@@ -1,25 +0,0 @@
-import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
-import { EventEmitHandler } from './eventEmitHandler';
-import { EventEmitter } from '../../../../stencil-public-runtime';
-import { EventSemantics } from '../../internalVegaEventManager';
-/** The `VegaEventEmitHandlerSlimmer` class is a TypeScript class that handles the emission of Vega events based on the availability of the 'emit' function and the event semantics namespace. */
-export declare class VegaEventEmitHandlerSlimmer extends VegaSlimmer implements EventEmitHandler {
-  protected vegaEvent: EventEmitter;
-  protected nativeEvent: EventEmitter;
-  /**
-   * The function determines whether a Vega event should be emitted based on the namespace and the availability of the 'emit' function.
-   *
-   * @param {EventSemantics} namespace the event semantics namespace
-   * @returns {boolean} a boolean value.
-   */
-  canHandle: ({ namespace }: EventSemantics) => boolean;
-  /**
-   * The function emits a Vega event with a given detail.
-   *
-   * @param {unknown} detail - The "detail" parameter is a generic type parameter that represents the data or
-   * information that you want to emit with the event. It can be any type of data, such as a string,
-   * number, object, or custom class.
-   * @returns {CustomEvent} The emitted event.
-   */
-  handle: <T>(detail: T) => CustomEvent<T>;
-}

package/dist/types/helpers/event-manager/slimmers/eventEmitSlimmer.d.ts

@@ -1,63 +0,0 @@
-import { VegaSlimmer } from '../../../vega-slimmer/vega-slimmer-core';
-import { ClassPrototype } from '../../../types/class.type';
-import { EventEmitter } from '../../../stencil-public-runtime';
-import { VegaEventID } from '../eventID/vegaEventId';
-import { VegaEventEmitHandlerSlimmer } from './event-emit-handlers/vegaEventEmitHandler';
-import { NativeEventEmitHandlerSlimmer } from './event-emit-handlers/nativeEventEmitHandler';
-import { JqueryDelegatedEventEmitHandlerSlimmer } from './event-emit-handlers/jqueryDelegatedEventEmitHandler';
-import { Nullable } from '../../../types/general';
-import { DynamicMapFromClass } from '../../../helpers/slimmers/types';
-/** The EventEmitSlimmerBase class is a TypeScript class that extends VegaSlimmer and provides methods for emitting events with or without notifications. */
-export declare class EventEmitSlimmerBase extends VegaSlimmer {
-  host: HTMLElement;
-  eventID: VegaEventID;
-  vegaEvent: EventEmitter;
-  nativeEvent: EventEmitter;
-  protected vegaEventEmitHandler: VegaEventEmitHandlerSlimmer;
-  protected nativeEventEmitHandler: NativeEventEmitHandlerSlimmer;
-  protected jqueryDelegatedEventEmitHandler: JqueryDelegatedEventEmitHandlerSlimmer;
-  private eventName;
-  private eventHandlers;
-  /**
-   * The constructor function takes an object with an eventName property and assigns it to the eventName property of the class.
-   *
-   * @param {{ eventName: string }} eventName  - The constructor function takes in an object with a property called "eventName" of type
-   * string. The value of "eventName" is then assigned to the instance variable "this.eventName".
-   */
-  constructor({ eventID }: {
-    eventID: VegaEventID;
-  });
-  /**
-   * emit the vega component event
-   *
-   * @param {unknown} [detail] the event detail
-   * @param {Event} [e] the event object
-   * @returns {Nullable<Event>} The emitted event.
-   */
-  emit: <T>(detail?: T, e?: Event) => Nullable<Event>;
-  /**
-   * used to clean up and remove any observers that were added to the host element during the lifecycle of the class
-   */
-  removeObserverFromHost: () => void;
-  /**
-   * The function checks if a given HTML element has been removed from the document.
-   *
-   * @param {Nullable<HTMLElement>} node - The `node` parameter is of type `Nullable<HTMLElement>`, which means it can either be
-   * an `HTMLElement` or `null`. It represents the element that needs to be checked if it has been removed from the document.
-   * @returns {boolean} a boolean value.
-   */
-  private isNodeRemovedFromDocument;
-  /**
-   * The function initializes event handlers for different types of events.
-   */
-  private initialEventHandlers;
-}
-/**
- * The function `createEventEmitSlimmer` creates a slimmer version of an event emitter class by mapping specific properties and events.
- *
- * @param {ClassPrototype<unknown>} mapFromClass - The class prototype from which the event emitter will be created.
- * @param {VegaEventID} eventID - The eventName parameter is a VegaEventID that represents the name of the event.
- * @param {string} [nativeEventPropertyName] - usually the native event name is eventID#nativeName, set a property name when the native name is used by other method or property
- * @returns {EventEmitSlimmerBase} an instance of the `EventEmitSlimmerBase` class.
- */
-export declare function createEventEmitSlimmer<T extends DynamicMapFromClass>(mapFromClass: ClassPrototype<T>, eventID: VegaEventID, nativeEventPropertyName?: string): EventEmitSlimmerBase;

package/dist/types/helpers/event-manager/vegaEventManager.d.ts

@@ -1,38 +0,0 @@
-import { EventSemantics, EventSemanticsConfig } from './internalVegaEventManager';
-import { Nullable } from '../../types/general';
-import { VegaEventID } from './eventID/vegaEventId';
-import { VegaComponentName } from '../../types/ui.type';
-/**
- * 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.
- */
-declare 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: EventSemanticsConfig): void;
-  /**
-   * 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: HTMLElement): EventSemantics;
-  /**
-   * The function "getEnabledEventIdsByComponent" returns the all eventIds in component.
-   *
-   * @param {VegaComponentName} componentName - The component name,
-   * etc.
-   * @returns {Nullable<VegaEventID[]>} All eventIds.
-   */
-  getEnabledEventIdsByComponent(componentName: VegaComponentName): Nullable<VegaEventID[]>;
-}
-declare const _default: VegaEventManager;
-export default _default;