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

package/dist/collection/helpers/change-manager/subject/static-subject/staticSubjectTitle.js

@@ -0,0 +1,24 @@
+import { StaticSubject } from './staticSubject';
+export const SIDENAV_LINK_SELECTED_TOPIC = new StaticSubject('SIDENAV_LINK_SELECTED_TOPIC');
+export const LEFT_NAV_LINK_SELECTED_TOPIC = new StaticSubject('LEFT_NAV_LINK_SELECTED_TOPIC');
+export const ACCORDION_EXPAND_TOPIC = new StaticSubject('ACCORDION_EXPAND_TOPIC');
+export const FORM_RESET_OPERATION_TRIGGERED = new StaticSubject('FORM_RESET_OPERATION_TRIGGERED');
+export const FORM_FIELD_ELEMENT_DISCONNECTED = new StaticSubject('FORM_FIELD_ELEMENT_DISCONNECTED');
+export const FORM_SUBMIT = new StaticSubject('FORM_SUBMIT');
+export const FORM_RESET = new StaticSubject('FORM_RESET');
+export const RADIO_GROUP_DISABLED_CHANGE = new StaticSubject('RADIO_GROUP_DISABLED_CHANGE');
+export const CHECKBOX_GROUP_DISABLED_CHANGE = new StaticSubject('CHECKBOX_GROUP_DISABLED_CHANGE');
+export const FORM_FIELD_PENDING_VALID_CHANGE = new StaticSubject('FORM_FIELD_PENDING_VALID_CHANGE');
+export const TAB_PANEL_ADD_OR_DEL_TO_GROUP = new StaticSubject('TAB_PANEL_ADD_OR_DEL_TO_GROUP');
+export const TABLE_EXPAND_ROW = new StaticSubject('TABLE_EXPAND_ROW');
+export const TABLE_ROW_SELECTION = new StaticSubject('TABLE_ROW_SELECTION');
+export const TABLE_ROW_SELECTION_ALL = new StaticSubject('TABLE_ROW_SELECTION_ALL');
+export const TABLE_ROW_CLICK = new StaticSubject('TABLE_ROW_CLICK');
+export const SUB_STATE_CHANGE = new StaticSubject('SUB_STATE_CHANGE');
+export const FIELD_ERROR_MESSAGE_CHANGE = new StaticSubject('FIELD_ERROR_MESSAGE_CHANGE');
+export const DROPDOWN_ITEM_CLICK = new StaticSubject('DROPDOWN_ITEM_CLICK');
+export const CHECKBOX_VALUE_CHANGE = new StaticSubject('CHECKBOX_VALUE_CHANGE');
+export const RADIO_VALUE_CHANGE = new StaticSubject('RADIO_VALUE_CHANGE');
+export const FORM_ELEMENT_VALUE_CHANGE = new StaticSubject('FORM_ELEMENT_VALUE_CHANGE');
+export const FORM_ELEMENT_VALIDATE = new StaticSubject('FORM_EMEMENT_VALIDATE');
+export const FIELD_ERROR_STATE_CHANGE = new StaticSubject('FIELD_ERROR_STATE_CHANGE');

package/dist/collection/helpers/{observer → change-manager}/test/changeManager.test.js

@@ -1,8 +1,8 @@
 import ChangeManager from '../changeManager';
-import { Observer } from '../observer';
-import { Subject } from '../subject';
-const TEST_TOPIC = new Subject('SIDENAV_LINK_SELECTED_TOPIC');
-const OTHER_TOPIC = new Subject('SIDENAV_LINK_SELECTED_TOPIC');
+import { Observer } from '../observer/observer';
+import { StaticSubject } from '../subject/static-subject/staticSubject';
+const TEST_TOPIC = new StaticSubject('SIDENAV_LINK_SELECTED_TOPIC');
+const OTHER_TOPIC = new StaticSubject('SIDENAV_LINK_SELECTED_TOPIC');
 let result = '';
 const acceptable = (input) => typeof input === 'string';
 const observerListener = (input) => {
@@ -21,3 +21,10 @@ test('return result as expect when call unregister', () => {
   ChangeManager.notify(OTHER_TOPIC, '456');
   expect(result).not.toEqual('456');
 });
+test('should remove the subject when call clearObserversBySubject', () => {
+  const observer = new Observer(acceptable, observerListener.bind(this));
+  ChangeManager.register(OTHER_TOPIC, observer);
+  const length = ChangeManager['pubSubMap'].size;
+  ChangeManager.clearObserversBySubject(OTHER_TOPIC);
+  expect(ChangeManager['pubSubMap'].size).toEqual(length - 1);
+});

package/dist/collection/helpers/change-manager/test/domNodeSubjectFactory.test.js

@@ -0,0 +1,26 @@
+import { VegaClick } from '../../event-manager/eventID/vegaEventId';
+import changeManager from '../changeManager';
+import domNodesSubjectFactory from '../subject/dom-node-subject/domNodeSubjectFactory';
+import { DomNodeSubjectObserverFactory } from '../subject/dom-node-subject/domNodeSubjectObserverFactory';
+test('domNodesSubjectFactory', () => {
+  const div = document.createElement('div');
+  div.className = 'test';
+  expect(domNodesSubjectFactory.isExist(div, VegaClick)).toBeFalsy();
+  const divSubject = domNodesSubjectFactory.getSubject(div, VegaClick);
+  expect(divSubject).not.toBeNull();
+  expect(domNodesSubjectFactory.isExist(div, VegaClick)).toBeTruthy();
+  expect(divSubject.getDescription()).toEqual(`, this is a dom nodes subject of ${div.tagName}:${VegaClick.getVegaName()}.(class name:test, id:)`);
+  expect(domNodesSubjectFactory['isExist'].call(null, null)).toBeFalsy();
+});
+test('addUniqueObserverToNode', () => {
+  const div = document.createElement('div');
+  const length = changeManager['pubSubMap'].size;
+  const mockCallback = jest.fn();
+  DomNodeSubjectObserverFactory.addUniqueObserverToNode(div, VegaClick, mockCallback);
+  expect(changeManager['pubSubMap'].size).toEqual(length + 1);
+  changeManager.notify(domNodesSubjectFactory.getSubject(div, VegaClick), div);
+  expect(mockCallback).toBeCalledTimes(1);
+  DomNodeSubjectObserverFactory.addUniqueObserverToNode(div, VegaClick, mockCallback, (node) => node.tagName === 'SPAN');
+  changeManager.notify(domNodesSubjectFactory.getSubject(div, VegaClick), div);
+  expect(mockCallback).toBeCalledTimes(1);
+});

package/dist/collection/helpers/chart/baseChart.js

@@ -13,7 +13,7 @@ export class BaseChart {
     this.options = options;
     this.isLayoutSet = false;
     this.drawers = [];
-    const context = GraphContextFactory.get(options.mode, options.container);
+    const context = GraphContextFactory.get(options.mode, options.container.shadowRoot ? options.container.shadowRoot : options.container);
     this.dimensionController = new ChartDimensionController(options.container);
     this.renderer = RendererFactory.get(context);
     this.interactor = InteractorFactory.get(context);
@@ -73,6 +73,7 @@ export class BaseChart {
     const newLayout = this.dimensionController.mergeLayout(options.container.tagName, options.layout, options.legends && options.legends.length ? true : false);
     this.options = Object.assign(options, { layout: newLayout });
     this.dimensionController.setContainerWidthAndHeight(newLayout);
+    this.options.container.style.display = 'block';
   }
   /**
    * This function un-registers drawers from the interactor.

package/dist/collection/helpers/chart/interactingEntryGenerator/pieLegendHoverGenerator.js

@@ -39,7 +39,10 @@ export class PieLegendHoverGenerator extends InteractingEntryGenerator {
   shouldHandle(event) {
     var _a;
     const target = event.target;
-    const container = event.currentTarget.parentElement;
+    const currentTarget = event.currentTarget;
+    const container = currentTarget.parentElement && currentTarget.parentElement.nodeType !== 11
+      ? currentTarget.parentElement
+      : currentTarget.parentNode['host'];
     return (container.tagName === 'VEGA-PIE-CHART' &&
       (target.classList.contains('vega-chart-legend-item') ||
         !!((_a = target.parentElement) === null || _a === void 0 ? void 0 : _a.classList.contains('vega-chart-legend-item'))));

package/dist/collection/helpers/chart/test/interactingEntryGenerator/pieLegendHoverGenerator.test.js

@@ -13,4 +13,13 @@ describe('PieLegendHoverGenerator', () => {
     const mockTargetNoParent = document.createElement('div');
     expect(hoverGenerator['shouldHandle'](Object.assign(Object.assign({}, mouseEvent), { target: mockTargetNoParent, currentTarget }))).toBeFalsy();
   });
+  it('should get correct result when call the function using different parameters for line chart', () => {
+    const hoverGenerator = new PieLegendHoverGenerator();
+    const lineChart = document.createElement('vega-line-chart');
+    lineChart.attachShadow({ mode: 'open' });
+    const currentTarget = lineChart.shadowRoot.appendChild(document.createElement('div'));
+    const target = currentTarget.appendChild(document.createElement('div'));
+    const mouseEvent = new MouseEvent('click');
+    expect(hoverGenerator['shouldHandle'](Object.assign(Object.assign({}, mouseEvent), { target, currentTarget }))).toBeFalsy();
+  });
 });

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

@@ -0,0 +1,77 @@
+import { LogUtility } from '../../../utils/log';
+/** The code is defining an abstract class called `BaseStrategy` that implements the `JQueryDelegatedEventStrategy` interface. */
+export class BaseStrategy {
+  /**
+   * The function "getHostName" returns the VegaComponentName.
+   *
+   * @returns {VegaComponentName} The method is returning the value of the variable "vegaComponentName" of type VegaComponentName.
+   */
+  getHostName() {
+    return this.vegaComponentName;
+  }
+  /**
+   * The function "getEventName" returns the name of an event as a string.
+   *
+   * @returns {VegaNativeEventNameType} a string value, which is the eventName.
+   */
+  getEventName() {
+    return this.eventName;
+  }
+  /**
+   * The function handles a click event on a specified element and dispatches a custom event with an optional detail.
+   *
+   * @param {HTMLElement} vegaHost - The `vegaHost` parameter is an HTMLElement that represents the host element where the event will be dispatched.
+   * @param {unknown} [detail] - The `detail` parameter is an optional argument that represents additional information or data that can be passed along with the event. It can be of any type, as it is defined as `unknown`.
+   * @returns {Event} a custom event of type `Event`.
+   */
+  handle(vegaHost, detail) {
+    const target = this.createEventTarget(vegaHost);
+    target.style.display = 'none';
+    vegaHost.appendChild(target);
+    const clonedEvent = this.createEvent(this.eventName);
+    if (detail) {
+      Object.defineProperty(clonedEvent, 'detail', {
+        configurable: true,
+        value: detail,
+      });
+    }
+    target.dispatchEvent(clonedEvent);
+    target.remove();
+    return clonedEvent;
+  }
+  /**
+   * The function copies attributes from one HTML element to another, excluding attributes starting with "on", "id".
+   *
+   * @param {HTMLElement} element - The `element` parameter is an HTMLElement object that represents the
+   * source element from which the attributes will be copied.
+   * @param {HTMLElement} target - The target parameter is an HTMLElement where the attributes of the
+   * element parameter will be copied to.
+   */
+  copyAttributesToTarget(element, target) {
+    if (element && target) {
+      const attributes = Array.from(element.attributes).filter((attr) => !attr.name.startsWith('on'));
+      attributes.forEach((attr) => {
+        try {
+          target.setAttribute(attr.name, attr.value);
+        }
+        catch (_a) {
+          LogUtility.error(`Delegated strategy copy ${element.tagName} attribute '${attr.name}' error.`);
+        }
+      });
+    }
+  }
+  /**
+   * The function creates and returns a new event object based on the given event name.
+   *
+   * @param {VegaNativeEventNameType} eventName - The eventName parameter is the name of the event that
+   * you want to create. It can be any valid event name, such as "click", "keydown", "mouseover", etc.
+   * @returns {Event} a cloned event object.
+   */
+  createEvent(eventName) {
+    let clonedEvent = new Event(eventName, { bubbles: true, cancelable: true });
+    if (eventName === 'click') {
+      clonedEvent = new MouseEvent(eventName, { bubbles: true, cancelable: true });
+    }
+    return clonedEvent;
+  }
+}

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,46 @@
+import { VegaExpand, VegaClick, VegaDropdownClick, VegaPageUpdate, VegaChange, VegaClose, VegaCreate, VegaSearch, VegaDropdownShow, VegaDropdownHide, VegaDropdownSearch, VegaFormSubmit, VegaFormReset, VegaValidate, VegaRemove, VegaCancel, VegaFocus, VegaBlur, VegaToggleStatus, VegaOpen, VegaStateUpdate, VegaGroupClick, VegaMenuClick, VegaPageSizeChange, VegaPopoverShow, VegaPopoverHide, VegaCurrentStepUpdate, VegaSelectChange, VegaSelectAllChange, VegaRowClick, } from './vegaEventId';
+const entries = [
+  ['vega-accordion', [VegaExpand]],
+  ['vega-app-header-button', [VegaClick, VegaDropdownClick]],
+  ['vega-breadcrumb', [VegaClick]],
+  ['vega-button', [VegaClick]],
+  ['vega-button-circle', [VegaClick]],
+  ['vega-button-link', [VegaClick]],
+  ['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-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-pagination', [VegaChange, VegaPageSizeChange]],
+  ['vega-popover', [VegaPopoverShow, VegaPopoverHide]],
+  ['vega-progress-tracker', [VegaCurrentStepUpdate]],
+  ['vega-radio', [VegaChange, VegaFocus, VegaBlur]],
+  ['vega-radio-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

@@ -0,0 +1,87 @@
+/** 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 HTMLNativeEventIds = [VegaChange, VegaClick, VegaFocus, VegaBlur];

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

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

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

@@ -0,0 +1,21 @@
+/** The class VegaInternalEventID implements the VegaEventIDInterface and provides a method to get the current name. */
+export class VegaInternalEventID {
+  /**
+   * 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) {
+    this.name = name;
+  }
+  /**
+   * 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() {
+    return this.name;
+  }
+}
+export const VegaInternalValid = new VegaInternalEventID('valid');
+export const VegaInternalFieldErrorStateChange = new VegaInternalEventID('fieldErrorStateChange');