@heartlandone/vega 2.0.0-temp-test-0.2 → 2.0.0

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,79 @@
+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 HTMLNativeEventIds: VegaEventID[];

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

@@ -0,0 +1,3 @@
+export interface VegaEventIDInterface {
+  getName(): string;
+}

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

@@ -0,0 +1,19 @@
+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;

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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,47 @@
+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

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

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

@@ -0,0 +1,31 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { EventEmitHandler } from './eventEmitHandler';
+import { EventSemantics } from '../../internalVegaEventManager';
+import { VegaEventID } from '../../eventID/vegaEventId';
+/** 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
+   */
+  handle: <T>(detail: T, e?: Event) => void;
+}

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

@@ -0,0 +1,24 @@
+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
+   */
+  handle: <T>(detail: T, e?: Event) => void;
+}

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

@@ -0,0 +1,24 @@
+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.
+   */
+  handle: <T>(detail: T) => void;
+}

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

@@ -0,0 +1,66 @@
+import { VegaSlimmer } from '../../../vega-slimmer/vega-slimmer-core';
+import { HTMLStencilElement } from '../../../stencil-public-runtime';
+import { ClassMethodType, 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';
+/** 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
+   */
+  emit: <T>(detail?: T, e?: Event) => void;
+  /**
+   * 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;
+}
+interface EventEmitFromClass {
+  host: HTMLStencilElement;
+  [name: string]: ClassMethodType | any;
+}
+/**
+ * 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 EventEmitFromClass>(mapFromClass: ClassPrototype<T>, eventID: VegaEventID, nativeEventPropertyName?: string): EventEmitSlimmerBase;
+export {};

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

@@ -0,0 +1 @@
+import '../../../polyfill/test-polyfill/unit/index';

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

@@ -0,0 +1 @@
+import '../../../polyfill/test-polyfill/unit/index';

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,38 @@
+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;

package/dist/types/helpers/feature-control/featureFlag.d.ts

@@ -38,4 +38,7 @@ export type FeatureFlagKey =
 	| 'VEGA_VUE.EMIT_CAMEL_CASE_EVENT_NAME'
 	| 'VEGA_ITEM_TOGGLE_ISERROR_DEPRECATED'
 	| 'VEGA_BUTTON_LINK.DEPRECATED_EVENTFUL'
-	| 'VEGA_DROPDOWN.RENAME_PREFIX_TO_PREFIX_ICON';
+	| 'VEGA_DROPDOWN.RENAME_PREFIX_TO_PREFIX_ICON'
+	| 'VEGA_REACT.PREVENT_CALL_WATCH_METHOD_BEFORE_COMPONENT_LOAD'
+	| 'VEGA_FRAMEWORK.PREVENT_CALL_WATCH_METHOD_BEFORE_COMPONENT_LOAD'
+	| 'VEGA_REACT.ENABLE_ON_CHANGE_HANDLE_UNDER_LOW_VERSION';

package/dist/types/helpers/formatter/responsive-map-formatter/responsiveBorderRadiusFomatter.d.ts

@@ -0,0 +1,27 @@
+import { BreakpointsForPrefixType, CornersType } from '../../../types/ui.type';
+import { ResponsiveClassStringFormatter } from './responsiveClassStringFormatter';
+/**
+ * A class for format BorderRadiusType with BreakpointsForPrefixType to CSS class string
+ *
+ * @augments ResponsiveClassStringFormatter
+ */
+declare class ResponsiveBorderRadiusFormatter extends ResponsiveClassStringFormatter<'corners'> {
+  /**
+   * 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: CornersType, breakpoint?: BreakpointsForPrefixType): string;
+  /**
+   * 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 .
+   */
+  private transformRoundedNoneAndFill;
+}
+declare const _default: ResponsiveBorderRadiusFormatter;
+export default _default;