@globalpayments/vega 2.45.0 → 2.47.0

package/dist/cjs/design-token-61572ad6.js

@@ -1,403 +0,0 @@
-'use strict';
-
-const typeGuard = require('./type-guard-4ba85fdc.js');
-const breakpoints = require('./breakpoints-ebde4837.js');
-const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
-const responsiveFormatFacade = require('./responsive-format-facade-bf7d9ab2.js');
-const typography = require('./typography-4560e7f1.js');
-const stateBackgroundColorFormatter = require('./state-background-color-formatter-e585a027.js');
-const ui = require('./ui-32e69595.js');
-
-/**
- * The `StateBorderColorFormatter` class in TypeScript formats border color tokens based on
- * input values and provides an array of CSS states.
- */
-class StateBorderColorFormatter extends stateBackgroundColorFormatter.StateVariantFormatter {
-  constructor() {
-    super(...arguments);
-    this.states = ['default', 'focus-visible', 'hover', 'active'];
-  }
-  /**
-   * The function `formatToken` takes a BorderColorsTokenType input, checks if it is a valid border
-   * color token type, and returns the corresponding CSS border-color value or logs a warning if the
-   * input is invalid.
-   *
-   * @param {BorderColorsTokenType} input - BorderColorsTokenType
-   * @returns {string} The `formatToken` function returns a string that represents a CSS style for border color
-   * based on the input `BorderColorsTokenType`. If the input is a valid border color token type, it
-   * retrieves the corresponding value from the `BorderColorMap` and returns a CSS style string with the
-   * border color value. If the input is not a valid border color token type, it logs a warning message
-   * and returns an
-   */
-  formatToken(input) {
-    if (typeGuard.isBorderColorTokenType(input)) {
-      const tokenValue = typeGuard.BorderColorMap[input];
-      return `border-color: ${tokenValue};`;
-    }
-    else {
-      globalSlimmerRegistry.LogUtility.warn(`The borderColor value ${input} is invalid, it must be a value of: `, typeGuard.BorderColors);
-      return '';
-    }
-  }
-  /**
-   * The function `getStates` returns an array of `CssStatesType` objects.
-   *
-   * @returns {CssStatesType[]} An array of CssStatesType objects is being returned.
-   */
-  getStates() {
-    return this.states;
-  }
-}
-const StateBorderColorFormatter$1 = new StateBorderColorFormatter();
-
-/**
- * The `StateShadowFormatter` class in TypeScript formats a CSS `box-shadow` property based on a
- * ShadowsTokenType input and provides an array of CssStatesType objects.
- */
-class StateShadowFormatter extends stateBackgroundColorFormatter.StateVariantFormatter {
-  constructor() {
-    super(...arguments);
-    this.states = ['default', 'focus-visible', 'hover'];
-  }
-  /**
-   * The `formatToken` function in TypeScript takes a ShadowsTokenType input, validates it, and returns a
-   * formatted CSS box-shadow property string or logs a warning if the input is invalid.
-   *
-   * @param {ShadowsTokenType} input - ShadowsTokenType
-   * @returns {string} The `formatToken` function takes a `ShadowsTokenType` input and returns a CSS `box-shadow`
-   * property with the corresponding value from the `ShadowMap` object. If the input is not a valid
-   * `ShadowsTokenType`, it logs a warning message using `LogUtility.warn` and returns an empty string.
-   */
-  formatToken(input) {
-    if (typeGuard.isShadowsTokenType(input)) {
-      const tokenValue = typeGuard.ShadowMap[input];
-      return `box-shadow: ${tokenValue};`;
-    }
-    else {
-      globalSlimmerRegistry.LogUtility.warn(`The shadow value ${input} is invalid, it must be a value of: `, typeGuard.Shadows);
-      return '';
-    }
-  }
-  /**
-   * The function `getStates` returns an array of `CssStatesType` objects.
-   *
-   * @returns {CssStatesType[]}An array of CssStatesType objects is being returned.
-   */
-  getStates() {
-    return this.states;
-  }
-}
-const StateShadowFormatter$1 = new StateShadowFormatter();
-
-/**
- * The `StateBorderFormatter` class in TypeScript formats border token values into CSS border properties
- * and provides state information.
- */
-class StateBorderFormatter extends stateBackgroundColorFormatter.StateVariantFormatter {
-  constructor() {
-    super(...arguments);
-    this.states = ['default', 'focus-visible', 'hover', 'active'];
-  }
-  /**
-   * The `formatToken` function in TypeScript formats a border token value into a CSS border property
-   * string or logs a warning if the input is invalid.
-   *
-   * @param {BordersTokenType} input - The `formatToken` function takes a `BordersTokenType` as input
-   * and returns a formatted string representing a CSS border property based on the input token value.
-   * If the input is a valid border token type, it retrieves the corresponding CSS value from the
-   * `BorderMap` and returns it in a `border
-   * @returns {string} The `formatToken` function returns a string that represents a CSS border property based on
-   * the input `BordersTokenType`. If the input is a valid border token type, it retrieves the
-   * corresponding value from the `BorderMap` and returns a CSS `border` property string. If the input
-   * is not a valid border token type, it logs a warning message using `LogUtility.warn` and returns an
-   * empty
-   */
-  formatToken(input) {
-    if (typeGuard.isBorderTokenType(input)) {
-      const tokenValue = typeGuard.BorderMap[input];
-      return `border: ${tokenValue};`;
-    }
-    else {
-      globalSlimmerRegistry.LogUtility.warn(`The border value ${input} is invalid, it must be a value of: `, typeGuard.Borders);
-      return '';
-    }
-  }
-  /**
-   * The function `getStates` returns an array of `CssStatesType` objects.
-   *
-   * @returns {CssStatesType[] } An array of objects of type CssStatesType, which represents the states.
-   */
-  getStates() {
-    return this.states;
-  }
-}
-const StateBorderFormatter$1 = new StateBorderFormatter();
-
-/**
- * The `StateFormatFacade` class in TypeScript provides a method to format different types of
- * state variants based on a specified flag.
- */
-class StateFormatFacade {
-  /**
-   * The function `format` takes in an input and a flag, then formats the input based on the flag
-   * provided.
-   *
-   * @param {StateVariantType} input - The `input` parameter in the `format` function is of type
-   * `StateVariantType<ManagedStateScopeInput[Flag], State>`. This means that it expects an input value
-   * that corresponds to the specified flag and state. The `Flag` type is a key of
-   * `ManagedStateScopeInput
-   * @param {keyof ManagedStateScopeInput} flag - The `flag` parameter in the `format` function is a key of the
-   * `ManagedStateScopeInput` type. It is used to determine which formatting logic to apply based on the
-   * specific flag provided. The function then switches on the flag value to select the appropriate
-   * formatting logic for that particular flag.
-   * @returns {string} The `format` function takes in an input of type
-   * `StateVariantType<ManagedStateScopeInput[Flag], State>` and a flag of type `Flag`. It then switches
-   * on the flag value and returns a formatted string based on the flag value. The return value depends
-   * on the flag value:
-   */
-  format(input, flag) {
-    switch (flag) {
-      case 'backgroundColor':
-        return stateBackgroundColorFormatter.stateBackgroundColorFormatter.format(input);
-      case 'borderColor':
-        return StateBorderColorFormatter$1.format(input);
-      case 'shadow':
-        return StateShadowFormatter$1.format(input);
-      case 'border':
-        return StateBorderFormatter$1.format(input);
-      default:
-        throw new Error(`Invalid flag ${flag} passed into StateFormatFacade`);
-    }
-  }
-}
-const StateFormatFacade$1 = new StateFormatFacade();
-
-/**
- * It logs a warning message to the console.
- *
- * @param {string} tokenType - The name of the token type.
- * @param {unknown} value - The value that was passed into the token.
- * @param {unknown} availableOptions - The available options for the token type.
- */
-function logInvalidValueMessage(tokenType, value, availableOptions) {
-  globalSlimmerRegistry.LogUtility.warn(`The ${tokenType} value ${value} is invalid, it must be a value of: `, availableOptions);
-}
-/**
- * Given a token and an array of modes, return a string with the token formatted with the appropriate mode
- *
- * @param {string} token - The name of the token.
- * @param {TokenMode[]} modes - TokenMode[]
- * @returns {string} The formatted token.
- */
-function formatTokenWithModes(token, modes) {
-  let formattedToken = '';
-  if (modes.includes('dark')) {
-    formattedToken += ` dark:v-dark-${token}`;
-  }
-  return formattedToken;
-}
-/**
- * If the token is a valid spacing token, return the CSS class string. Otherwise, log an error message
- *
- * @param {unknown} token - The value that was passed into the function.
- * @returns {Nullable<string>} The the CSS class string of the padding token.
- */
-function formatAndValidPadding(token) {
-  if (typeGuard.isSpacingTokenType(token)) {
-    return `v-p-${token}`;
-  }
-  else {
-    logInvalidValueMessage('padding', token, Object.keys(typeGuard.Spacing));
-  }
-}
-/**
- * The function `formatAndValidBorderStyle` formats a border style token and returns a string if it is
- * a valid border style type, otherwise it logs an invalid value message.
- *
- * @param {unknown} token - The `token` parameter is a value that represents a border style type.
- * @returns {Nullable<string>} The function `formatAndValidBorderStyle` returns a string that is formatted as
- * `v-border-` if the `token` parameter is of a valid border style type. If the `token` is not
- * a valid border style type, it logs an invalid value message and does not return anything (implicitly
- * returns `undefined`).
- */
-function formatAndValidBorderStyle(token) {
-  if (typeGuard.isBorderStyleType(token)) {
-    return `v-border-${token}`;
-  }
-  else {
-    logInvalidValueMessage('border-style', token, ui.BorderStyle);
-  }
-}
-/**
- * If the token is a valid border radius, return a string with the token prefixed with `v-rounded-`. Otherwise, log an
- * error message
- *
- * @param {unknown} token - The value passed in by the user.
- * @returns {Nullable<string>} The the CSS class string of the border radius token.
- */
-function formatAndValidBorderRadius(token) {
-  if (typeGuard.isBorderRadiusTokenType(token)) {
-    return `v-${token}`;
-  }
-  else {
-    logInvalidValueMessage('border-radius', token, Object.keys(typeGuard.BorderRadius));
-  }
-}
-/**
- * If the token is a valid border color, return CSS class string of the border color. Otherwise, log an error message
- *
- * @param {unknown} token - The value passed in by the user.
- * @returns {Nullable<string>}  return the CSS class string of the border color
- */
-function formatAndValidBorderColor(token) {
-  if (typeGuard.isBorderColorTokenType(token)) {
-    return `v-${token}`;
-  }
-  else {
-    logInvalidValueMessage('border-color', token, typeGuard.Colors.filter(() => /^border-color-.+$/.test));
-  }
-}
-/**
- * If the token is a valid background color, return it with the v- prefix. Otherwise, log an error
- *
- * @param {unknown} token - The value of the token.
- * @param {TokenMode[]} withModes - TokenMode[] = []
- * @returns {Nullable<string>} CSS class string for the background color token with modes supported.
- */
-function formatAndValidBackgroundColor(token, withModes = []) {
-  if (typeGuard.isBackgroundColorTokenType(token)) {
-    return `v-${token}` + formatTokenWithModes(token, withModes);
-  }
-  else {
-    logInvalidValueMessage('background-color', token, typeGuard.Colors.filter(() => /^bg-.+$/.test));
-  }
-}
-/**
- * If the token is a valid text color, return the token prefixed with `v-` and formatted with the given modes. Otherwise,
- * log an error
- *
- * @param {unknown} token - The token to format.
- * @param {TokenMode[]} withModes - TokenMode[] = []
- * @returns {Nullable<string>} A CSS class string that is either a valid color or a valid color with modes.
- */
-function formatAndValidTextColor(token, withModes = []) {
-  if (typeGuard.isTextColorTokenType(token)) {
-    return `v-${token}` + formatTokenWithModes(token, withModes);
-  }
-  else {
-    logInvalidValueMessage('text-color', token, typeGuard.Colors.filter(() => /^text-.+$/.test));
-  }
-}
-/**
- * If the token is a valid breakpoint, return CSS class string for the flex breakpoint. Otherwise, log an error
- *
- * @param {unknown} token - The value of the breakpoint.
- * @returns {Nullable<string>} CSS class string for the flex breakpoint.
- */
-function formatAndValidFlexBreakpoint(token) {
-  if (typeGuard.isBreakpointsTokenType(token)) {
-    return `vega-flex-${token}`;
-  }
-  else {
-    logInvalidValueMessage('breakpoint', token, Object.keys(breakpoints.Breakpoints));
-  }
-}
-/**
- * If the token is a breakpoint, return the breakpoint value. Otherwise, log an error and return 0
- *
- * @param {unknown} token - The value passed in by the user.
- * @returns {Nullable<number>} value of the breakpoint.
- */
-function formatAndValidBreakpointSize(token) {
-  if (typeGuard.isBreakpointsTokenType(token)) {
-    return breakpoints.Breakpoints[token];
-  }
-  else {
-    logInvalidValueMessage('breakpoint', token, Object.keys(breakpoints.Breakpoints));
-  }
-}
-/**
- * If the token is a valid spacing token, return a string with the token name prefixed with `v-gap-`. Otherwise, log an
- * error message
- *
- * @param {unknown} token - The value passed in by the user.
- * @returns {Nullable<string>} CSS class string for the given gap token.
- */
-function formatAndValidGap(token) {
-  if (typeGuard.isSpacingTokenType(token)) {
-    return `v-gap-${token}`;
-  }
-  else {
-    logInvalidValueMessage('gap', token, Object.keys(typeGuard.Spacing));
-  }
-}
-/**
- * If the token is a valid shadows token type, return the token with the prefix "v-". Otherwise, log an error message
- *
- * @param {string} token - The token to format.
- * @param {TokenMode[]} withModes - TokenMode[] = []
- * @returns {Nullable<string>} CSS class string of the shadow token with modes supported
- */
-function formatAndValidShadow(token, withModes = []) {
-  if (typeGuard.isShadowsTokenType(token)) {
-    return `v-${token}` + formatTokenWithModes(token, withModes);
-  }
-  else {
-    logInvalidValueMessage('shadows', token, typeGuard.Shadows);
-  }
-}
-/**
- * It takes a token and a flag, and returns a string
- *
- * @typedef Flag key of ManagedResponsiveScopeInput
- * @param {ResponsiveType<ManagedResponsiveScopeInput[Flag]>} token - The token to format.
- * @param {Flag} flag - The flag that the token is being formatted for.
- * @returns {Nullable<ManagedResponsiveScopeOutput[Flag]>} A nullable string
- */
-function formatAndValidResponsiveToken(token, flag) {
-  if (token !== null && token !== undefined) {
-    return responsiveFormatFacade.ResponsiveFormatFacade.format(token, flag);
-  }
-}
-/**
- * The function `formatAndValidTypographyToken` formats a typography token by adding a prefix and checks if it is a valid typography token.
- *
- * @param {string} token - The `token` parameter is a string that represents a typography token.
- * @returns {Nullable<string>} a string value.
- */
-function formatAndValidTypographyToken(token) {
-  if (typeGuard.isTypographyTokenType(token)) {
-    return `v-${token}`;
-  }
-  else {
-    logInvalidValueMessage('font', token, typography.TypographyKeys);
-  }
-}
-/**
- * The function `formatAndValidStateToken` formats and validates a state token based on a specified flag.
- *
- * @param {StateVariantType} token - The `token` parameter is a value that represents a state variant for a specific flag
- * in a managed state scope input.
- * @param {Flag} flag - The `flag` parameter is a key of the `ManagedStateScopeInput` type.
- * @returns {Nullable<string>} a formatted and validated state token as a string, or `null` if the input token is `null`
- * or `undefined`.
- */
-function formatAndValidStateToken(token, flag) {
-  if (token !== null && token !== undefined) {
-    return StateFormatFacade$1.format(token, flag);
-  }
-}
-
-exports.formatAndValidBackgroundColor = formatAndValidBackgroundColor;
-exports.formatAndValidBorderColor = formatAndValidBorderColor;
-exports.formatAndValidBorderRadius = formatAndValidBorderRadius;
-exports.formatAndValidBorderStyle = formatAndValidBorderStyle;
-exports.formatAndValidBreakpointSize = formatAndValidBreakpointSize;
-exports.formatAndValidFlexBreakpoint = formatAndValidFlexBreakpoint;
-exports.formatAndValidGap = formatAndValidGap;
-exports.formatAndValidPadding = formatAndValidPadding;
-exports.formatAndValidResponsiveToken = formatAndValidResponsiveToken;
-exports.formatAndValidShadow = formatAndValidShadow;
-exports.formatAndValidStateToken = formatAndValidStateToken;
-exports.formatAndValidTextColor = formatAndValidTextColor;
-exports.formatAndValidTypographyToken = formatAndValidTypographyToken;

package/dist/cjs/dom-node-subject-factory-6a2aa462.js

@@ -1,280 +0,0 @@
-'use strict';
-
-const ui = require('./ui-13b42af0.js');
-
-/**
- *  An Observer is a class that has a listener method that accepts a value of type T
- *  and calls the listener method with a value of type T
- */
-class Observer {
-  /**
-   * It accepts a function that accepts a value and returns a boolean, and a function that accepts a value of the type that
-   * the first function accepts
-   *
-   * @typedef T generic type parameter
-   * @param {(input: unknown) => input is T} accept - A function that indicate if the input is acceptable by the observer
-   * @param {(input: T) => void} listener - A function handle the input for the observer if the input is accepted
-   */
-  constructor(accept, listener) {
-    this.accept = accept;
-    this.listener = listener;
-  }
-  /**
-   * If the input is of the type that this handler is interested in, then call the listener function
-   *
-   * @param {unknown} input - unknown
-   */
-  notify(input) {
-    if (this.accept(input)) {
-      this.listener(input);
-    }
-  }
-}
-
-/** The VegaEventID class represents an event ID with both a Vega name and a native name. */
-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);
-  }
-}
-const VegaChange = new VegaEventID('vegaChange', 'change');
-const VegaClick = new VegaEventID('vegaClick', 'click');
-const VegaFocus = new VegaEventID('vegaFocus', 'focus');
-const VegaBlur = new VegaEventID('vegaBlur', 'blur');
-const VegaClose = new VegaEventID('vegaClose', 'close');
-const VegaOpen = new VegaEventID('vegaOpen', 'modalOpen');
-const VegaValidate = new VegaEventID('vegaValidate', 'validate');
-const VegaFormSubmit = new VegaEventID('vegaFormSubmit', 'formSubmit');
-const VegaFormReset = new VegaEventID('vegaFormReset', 'formReset');
-const VegaRowClick = new VegaEventID('vegaRowClick', 'rowClick');
-const VegaRowExpand = new VegaEventID('vegaRowExpand', 'rowExpand');
-const VegaSelectChange = new VegaEventID('vegaSelectChange', 'selectChange');
-const VegaRowSelect = new VegaEventID('vegaRowSelect', 'rowSelect');
-const VegaRowSelectAll = new VegaEventID('vegaRowSelectAll', 'rowSelectAll');
-const VegaSelectAllChange = new VegaEventID('vegaSelectAllChange', 'selectAllChange');
-const VegaPageSizeChange = new VegaEventID('vegaPageSizeChange', 'pageSizeChange');
-const VegaDropdownClick = new VegaEventID('vegaDropdownClick', 'dropdownClick');
-const VegaCreate = new VegaEventID('vegaCreate', 'create');
-const VegaSearch = new VegaEventID('vegaSearch', 'search');
-const VegaSearchTrigger = new VegaEventID('vegaSearchTrigger', 'searchTrigger');
-const VegaHide = new VegaEventID('vegaHide', 'hide');
-const VegaShow = new VegaEventID('vegaShow', 'show');
-const VegaPopoverShow = new VegaEventID('vegaPopoverShow', 'popoverShow');
-const VegaPopoverHide = new VegaEventID('vegaPopoverHide', 'popoverHide');
-const VegaCancel = new VegaEventID('vegaCancel', 'cancel');
-const VegaRemove = new VegaEventID('vegaRemove', 'remove');
-const VegaPageUpdate = new VegaEventID('vegaPageUpdate', 'pageUpdate');
-const VegaCurrentStepUpdate = new VegaEventID('vegaCurrentStepUpdate', 'currentStepUpdate');
-const VegaToggleStatus = new VegaEventID('vegaToggleStatus', 'toggleStatus');
-const VegaStateUpdate = new VegaEventID('vegaStateUpdate', 'stateUpdate');
-const VegaGroupClick = new VegaEventID('vegaGroupClick', 'groupClick');
-const VegaMenuClick = new VegaEventID('vegaMenuClick', 'menuClick');
-const VegaExpand = new VegaEventID('vegaExpand', 'expand');
-const VegaDropdownShow = new VegaEventID('vegaShow', 'dropdownShow');
-const VegaDropdownHide = new VegaEventID('vegaHide', 'dropdownHide');
-const VegaDropdownSearch = new VegaEventID('vegaSearch', 'dropdownSearch');
-const VegaActionClick = new VegaEventID('vegaActionClick', 'actionClick');
-const VegaEventClick = new VegaEventID('vegaEventClick', 'eventClick');
-const VegaDateDblClick = new VegaEventID('vegaDateDblClick', 'dateDblClick');
-const VegaCountryChange = new VegaEventID('vegaCountryChange', 'countryChange');
-const VegaActionButtonClick = new VegaEventID('vegaActionButtonClick', 'actionButtonClick');
-const VegaMoreActionClick = new VegaEventID('vegaMoreActionClick', 'moreActionClick');
-const VegaSelectFileChange = new VegaEventID('vegaSelectedFileChange', 'selectedFileChange');
-const VegaImageInserted = new VegaEventID('vegaImageInserted', 'imageInserted');
-const VegaRetry = new VegaEventID('vegaRetry', 'retry');
-const VegaPreview = new VegaEventID('vegaPreview', 'preview');
-const VegaLabelButtonClick = new VegaEventID('vegaLabelButtonClick', 'labelButtonClick');
-const HTMLNativeEventIds = [VegaChange, VegaClick, VegaFocus, VegaBlur];
-
-/** The DomNodeSubject class represents a subject related to DOM nodes. */
-class DomNodeSubject {
-  /**
-   * The constructor function takes a SubjectTitle parameter and assigns it to the private title property.
-   *
-   * @param {SubjectTitle} title - The "title" parameter is a private property of the class that is of type "SubjectTitle".
-   * @param {HTMLElement} host - The `host` parameter is an HTMLElement that represents the container or
-   * parent element where the subject title will be displayed. It is used to specify the location where
-   * the title will be rendered on the web page.
-   */
-  constructor(title, host) {
-    this.title = title;
-    this.host = host;
-  }
-  /**
-   * The getDescription function returns the title of an object as a string.
-   *
-   * @returns {string} The title of the object.
-   */
-  getDescription() {
-    return `, this is a dom nodes subject of ${this.title}.(class name:${this.host.className}, id:${this.host.id})`;
-  }
-}
-
-/** The `DomNodesSubjectFactory` class is responsible for managing and caching `DomNodeSubject` objects associated with HTML elements. */
-class DomNodeSubjectFactory {
-  constructor() {
-    this.cache = new Map();
-  }
-  /**
-   * The function `getSubject` returns the subject associated with a given node and event ID, either from the cache or by setting it if it doesn't exist.
-   *
-   * @param {HTMLElement} node - The `node` parameter is an HTMLElement, which represents an element in the HTML document.
-   * @param {VegaEventIDInterface} eventId - The `eventId` parameter is of type `VegaEventIDInterface`. It represents the ID of the event for which we want to get the subject.
-   * @returns {DomNodeSubject} a `DomNodeSubject` object.
-   */
-  getSubject(node, eventId) {
-    if (this.isExist(node, eventId)) {
-      return this.cache.get(node).get(eventId);
-    }
-    else {
-      return this.setSubject(node, eventId);
-    }
-  }
-  /**
-   * The function checks if a given node exists in the cache and if it has a specific event ID.
-   *
-   * @param {HTMLElement} node - The "node" parameter is an HTMLElement, which represents an HTML element in the DOM (Document Object Model). It could be any HTML element such as a div, span, button, etc.
-   * @param {VegaEventIDInterface} eventId - The `eventId` parameter is of type `VegaEventIDInterface`. It represents an event ID that is used to identify a specific event.
-   * @returns {boolean} a boolean value.
-   */
-  isExist(node, eventId) {
-    if (node) {
-      return (this.cache.has(node) &&
-        this.cache.get(node) !== undefined &&
-        this.cache.get(node).has(eventId));
-    }
-    return false;
-  }
-  /**
-   * The function find if the parent of a given node exists in the cache and if it has a specific event ID.
-   *
-   * @param {HTMLElement} childNode - Child node.
-   * @param {VegaEventIDInterface} eventId - eventId.
-   * @returns {Nullable<DomNodeSubject>} - Parent node subject.
-   */
-  getSubjectFromParentNodeByEventId(childNode, eventId) {
-    let subject;
-    for (const entry of this.cache) {
-      if (ui.isParent(childNode, entry[0]) && entry[1].has(eventId)) {
-        subject = entry[1].get(eventId);
-        break;
-      }
-    }
-    return subject;
-  }
-  /**
-   * The function `setSubject` creates a new `DomNodeSubject` and associates it with a given `node` and `eventId`, and then returns the created subject.
-   *
-   * @param {HTMLElement} node - The `node` parameter is an HTMLElement object representing an HTML element in the DOM (Document Object Model).
-   * @param {VegaEventIDInterface} eventId - The `eventId` parameter is of type `VegaEventIDInterface`. It represents the ID of a Vega event.
-   * @returns {DomNodeSubject} dom node subject object
-   */
-  setSubject(node, eventId) {
-    const subjectTitle = `${node.tagName}:${eventId.getName()}`;
-    const subject = new DomNodeSubject(subjectTitle, node);
-    if (!this.cache.get(node)) {
-      this.cache.set(node, new Map());
-    }
-    this.cache.get(node).set(eventId, subject);
-    return subject;
-  }
-}
-const domNodeSubjectFactory = new DomNodeSubjectFactory();
-
-exports.Observer = Observer;
-exports.VegaActionButtonClick = VegaActionButtonClick;
-exports.VegaActionClick = VegaActionClick;
-exports.VegaBlur = VegaBlur;
-exports.VegaCancel = VegaCancel;
-exports.VegaChange = VegaChange;
-exports.VegaClick = VegaClick;
-exports.VegaClose = VegaClose;
-exports.VegaCountryChange = VegaCountryChange;
-exports.VegaCreate = VegaCreate;
-exports.VegaCurrentStepUpdate = VegaCurrentStepUpdate;
-exports.VegaDateDblClick = VegaDateDblClick;
-exports.VegaDropdownClick = VegaDropdownClick;
-exports.VegaDropdownHide = VegaDropdownHide;
-exports.VegaDropdownSearch = VegaDropdownSearch;
-exports.VegaDropdownShow = VegaDropdownShow;
-exports.VegaEventClick = VegaEventClick;
-exports.VegaExpand = VegaExpand;
-exports.VegaFocus = VegaFocus;
-exports.VegaFormReset = VegaFormReset;
-exports.VegaFormSubmit = VegaFormSubmit;
-exports.VegaGroupClick = VegaGroupClick;
-exports.VegaHide = VegaHide;
-exports.VegaImageInserted = VegaImageInserted;
-exports.VegaLabelButtonClick = VegaLabelButtonClick;
-exports.VegaMenuClick = VegaMenuClick;
-exports.VegaMoreActionClick = VegaMoreActionClick;
-exports.VegaOpen = VegaOpen;
-exports.VegaPageSizeChange = VegaPageSizeChange;
-exports.VegaPageUpdate = VegaPageUpdate;
-exports.VegaPopoverHide = VegaPopoverHide;
-exports.VegaPopoverShow = VegaPopoverShow;
-exports.VegaPreview = VegaPreview;
-exports.VegaRemove = VegaRemove;
-exports.VegaRetry = VegaRetry;
-exports.VegaRowClick = VegaRowClick;
-exports.VegaRowExpand = VegaRowExpand;
-exports.VegaRowSelect = VegaRowSelect;
-exports.VegaRowSelectAll = VegaRowSelectAll;
-exports.VegaSearch = VegaSearch;
-exports.VegaSearchTrigger = VegaSearchTrigger;
-exports.VegaSelectAllChange = VegaSelectAllChange;
-exports.VegaSelectChange = VegaSelectChange;
-exports.VegaSelectFileChange = VegaSelectFileChange;
-exports.VegaShow = VegaShow;
-exports.VegaStateUpdate = VegaStateUpdate;
-exports.VegaToggleStatus = VegaToggleStatus;
-exports.VegaValidate = VegaValidate;
-exports.domNodeSubjectFactory = domNodeSubjectFactory;