@heartlandone/vega 2.78.0 → 2.80.0

package/dist/esm/internal-vega-event-manager-59f5bd47.js

@@ -0,0 +1,494 @@
+import { d as VegaExpand, a as VegaClick, V as VegaDropdownClick, e as VegaReset, f as VegaClose, g as VegaActionButtonClick, h as VegaChange, i as VegaEventClick, j as VegaDateDblClick, k as VegaMoreActionClick, l as VegaDateClick, m as VegaPageUpdate, n as VegaRemove, o as VegaCreate, p as VegaSearch, q as VegaMonthYearChange, r as VegaClear, s as VegaSelectionChange, t as VegaDropdownShow, u as VegaDropdownHide, v as VegaDropdownSearch, w as VegaSearchTrigger, x as VegaLabelButtonClick, y as VegaSelectFileChange, z as VegaRetry, A as VegaPreview, B as VegaFormSubmit, C as VegaFormReset, D as VegaValidate, E as VegaCancel, F as VegaNativeInputChange, G as VegaFocus, H as VegaBlur, I as VegaSuggestionItemClick, J as VegaPaste, K as VegaComplete, L as VegaCountryChange, M as VegaShow, N as VegaHide, O as VegaToggleStatus, P as VegaOpen, Q as VegaStateUpdate, R as VegaGroupClick, S as VegaMenuClick, T as VegaActionClick, U as VegaPageSizeChange, b as VegaPopoverShow, c as VegaPopoverHide, W as VegaCurrentStepUpdate, X as VegaImageInserted, Y as VegaSourceCodeChange, Z as VegaSelectChange, _ as VegaSelectAllChange, $ as VegaRowClick, a0 as VegaRowExpand, a1 as VegaRowSelect, a2 as VegaRowSelectAll } from './vega-event-id-4ede557a.js';
+import { L as LogUtility } from './global-slimmer-registry-17c4efd4.js';
+
+const entries = [
+  ['vega-accordion', [VegaExpand]],
+  ['vega-app-header-button', [VegaClick, VegaDropdownClick, VegaReset]],
+  ['vega-banner', [VegaClose, VegaActionButtonClick]],
+  ['vega-breadcrumb', [VegaClick]],
+  ['vega-button', [VegaClick]],
+  ['vega-button-circle', [VegaClick]],
+  ['vega-button-group', [VegaClick]],
+  ['vega-button-link', [VegaClick]],
+  ['vega-calendar', [VegaChange, VegaEventClick, VegaDateDblClick, VegaMoreActionClick, VegaDateClick]],
+  ['vega-carousel', [VegaPageUpdate]],
+  ['vega-checkbox', [VegaChange]],
+  ['vega-checkbox-group', [VegaChange]],
+  ['vega-chip', [VegaClose, VegaClick]],
+  ['vega-code-block', [VegaChange, VegaRemove]],
+  ['vega-color-picker', [VegaChange]],
+  ['vega-combo-box', [VegaChange, VegaCreate, VegaSearch]],
+  ['vega-date-picker', [VegaChange, VegaMonthYearChange]],
+  ['vega-date-picker-calendar', [VegaClear, VegaMonthYearChange, VegaSelectionChange]],
+  [
+    'vega-dropdown',
+    [
+      VegaDropdownShow,
+      VegaDropdownHide,
+      VegaDropdownClick,
+      VegaReset,
+      VegaCreate,
+      VegaDropdownSearch,
+      VegaSearchTrigger,
+    ],
+  ],
+  ['vega-dropdown-item', [VegaClick]],
+  ['vega-field-label', [VegaClick, VegaLabelButtonClick]],
+  ['vega-file-uploader', [VegaChange, VegaSelectFileChange, VegaRemove, VegaRetry, VegaPreview]],
+  ['vega-form', [VegaFormSubmit, VegaFormReset, VegaValidate]],
+  ['vega-image-uploader', [VegaChange, VegaRemove, VegaCancel]],
+  [
+    'vega-input',
+    [
+      VegaChange,
+      VegaNativeInputChange,
+      VegaFocus,
+      VegaBlur,
+      VegaLabelButtonClick,
+      VegaSuggestionItemClick,
+      VegaPaste,
+    ],
+  ],
+  ['vega-input-credit-card', [VegaChange, VegaBlur, VegaFocus]],
+  ['vega-input-numeric', [VegaChange]],
+  ['vega-input-passcode', [VegaChange, VegaComplete]],
+  ['vega-input-phone-number', [VegaChange, VegaCountryChange]],
+  ['vega-input-range', [VegaChange]],
+  [
+    'vega-input-select',
+    [VegaChange, VegaSearch, VegaSearchTrigger, VegaShow, VegaHide, VegaLabelButtonClick],
+  ],
+  ['vega-item-toggle', [VegaToggleStatus]],
+  ['vega-modal', [VegaOpen, VegaClose]],
+  ['vega-left-nav', [VegaStateUpdate]],
+  ['vega-left-nav-group', [VegaGroupClick]],
+  ['vega-left-nav-link', [VegaMenuClick]],
+  ['vega-left-nav-section', [VegaActionClick]],
+  ['vega-pagination', [VegaChange, VegaPageSizeChange]],
+  ['vega-popover', [VegaPopoverShow, VegaPopoverHide]],
+  ['vega-progress-tracker', [VegaCurrentStepUpdate]],
+  ['vega-radio', [VegaChange, VegaFocus, VegaBlur]],
+  ['vega-radio-group', [VegaChange]],
+  ['vega-rich-text-editor', [VegaChange, VegaImageInserted, VegaSourceCodeChange]],
+  ['vega-rich-text-editor-toolbar-button', [VegaClick]],
+  ['vega-rich-text-image-editor', [VegaChange]],
+  ['vega-rich-text-link-editor', [VegaChange]],
+  ['vega-segment-control', [VegaChange]],
+  ['vega-selection-chip', [VegaChange]],
+  ['vega-selection-chip-group', [VegaChange]],
+  ['vega-selection-tile', [VegaChange]],
+  ['vega-selection-tile-group', [VegaChange]],
+  ['vega-sidenav', [VegaStateUpdate]],
+  ['vega-sidenav-link', [VegaClick]],
+  ['vega-signature-capture', [VegaChange]],
+  ['vega-stepper', [VegaChange]],
+  ['vega-tab-group', [VegaClick]],
+  [
+    'vega-table',
+    [
+      VegaChange,
+      VegaSelectChange,
+      VegaSelectAllChange,
+      VegaRowClick,
+      VegaRowExpand,
+      VegaRowSelect,
+      VegaRowSelectAll,
+    ],
+  ],
+  ['vega-table-head-cell', [VegaClick]],
+  ['vega-table-row', [VegaClick, VegaExpand]],
+  ['vega-textarea', [VegaChange, VegaBlur, VegaLabelButtonClick]],
+  ['vega-time-picker', [VegaChange]],
+  ['vega-toggle-switch', [VegaChange]],
+];
+const VEGA_COMPONENT_EVENT_MAP = new Map(entries);
+
+/** The code is defining an abstract class called `BaseStrategy` that implements the `JQueryDelegatedEventStrategy` interface. */
+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;
+  }
+}
+
+/** The VegaButtonClickStrategy class is responsible for creating a button element when a click event is triggered on a VegaButton component. */
+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) {
+    // eslint-disable-next-line no-restricted-globals
+    const button = document.createElement('button');
+    this.copyAttributesToTarget(delegatedTarget, button);
+    button.type = delegatedTarget.type;
+    return button;
+  }
+}
+
+/** The VegaCheckboxChangeStrategy class is responsible for creating an event target and handling the change event for Vega checkboxes. */
+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) {
+    // eslint-disable-next-line no-restricted-globals
+    const input = document.createElement('input');
+    this.copyAttributesToTarget(delegatedTarget, input);
+    input.type = 'checkbox';
+    input.checked = delegatedTarget.checked;
+    return input;
+  }
+}
+
+/** 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. */
+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) {
+    // eslint-disable-next-line no-restricted-globals
+    const select = document.createElement('select');
+    this.copyAttributesToTarget(delegatedTarget, select);
+    if (delegatedTarget.value) {
+      select.value = delegatedTarget.value.toString();
+    }
+    return select;
+  }
+}
+
+/** The VegaInputBlurStrategy class is responsible for creating an input element when a blur event is triggered on a VegaInput component. */
+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) {
+    // eslint-disable-next-line no-restricted-globals
+    const input = document.createElement('input');
+    this.copyAttributesToTarget(delegatedTarget, input);
+    input.type = delegatedTarget.type;
+    input.value = delegatedTarget.value;
+    return input;
+  }
+}
+
+/** The VegaRadioChangeStrategy class is responsible for creating an input element for radio buttons and handling the 'change' event. */
+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) {
+    // eslint-disable-next-line no-restricted-globals
+    const input = document.createElement('input');
+    this.copyAttributesToTarget(delegatedTarget, input);
+    input.type = 'radio';
+    input.checked = delegatedTarget.checked;
+    return input;
+  }
+}
+
+/** The VegaTextareaChangeStrategy class is a TypeScript class that extends the BaseStrategy class and is used for handling the 'change' event for a VegaTextarea component. */
+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) {
+    // eslint-disable-next-line no-restricted-globals
+    const textarea = document.createElement('textarea');
+    this.copyAttributesToTarget(delegatedTarget, textarea);
+    textarea.value = delegatedTarget.value;
+    return textarea;
+  }
+}
+
+/** 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);
+      }
+    });
+  }
+}
+const jqueryDelegatedStrategyController = new JQueryDelegatedStrategyController();
+
+/**
+ * The `InternalVegaEventManager` class manages event semantics configuration for global and
+ * component-specific settings.
+ */
+class InternalVegaEventManager {
+  constructor() {
+    this.config = {};
+    this.defaultEventSemantics = {
+      namespace: 'vega',
+    };
+  }
+  /**
+   * The function sets the semantics configuration for events.
+   *
+   * @param {EventSemanticsConfig} config - The `config` parameter is of type `EventSemanticsConfig`.
+   */
+  setSemantics(config) {
+    this.config = config;
+    jqueryDelegatedStrategyController.updateRegistryFromEventSemantics(config);
+  }
+  /**
+   * The function `getSemantics` returns the event semantics either from the global scope or from the
+   * components within a given host element.
+   *
+   * @param {HTMLElement} host - The host parameter is an HTMLElement that represents the element on
+   * which the event semantics are being checked.
+   * @returns {EventSemantics} The method `getSemantics` returns a value of type `Nullable<EventSemantics>`.
+   */
+  getSemantics(host) {
+    return Object.assign({}, this.defaultEventSemantics, this.getSemanticsInGlobal(), this.getSemanticsInComponents(host));
+  }
+  /**
+   * The function "getEnabledEventIdsByComponent" returns an array of event Ids associated with a given component
+   * name.
+   *
+   * @param {VegaComponentName} componentName - The `componentName` parameter is a string that represents
+   * the name of a Vega component.
+   * @returns {Nullable<VegaEventID[]>} a nullable array of VegaEventID objects.
+   */
+  getEnabledEventIdsByComponent(componentName) {
+    return VEGA_COMPONENT_EVENT_MAP.get(componentName);
+  }
+  /**
+   * The function `getSemanticsInGlobal` returns the global event semantics configuration.
+   *
+   * @returns {Nullable<EventSemantics>} The method is returning a nullable EventSemantics object.
+   */
+  getSemanticsInGlobal() {
+    return this.config.global;
+  }
+  /**
+   * The function `getSemanticsInComponents` returns the semantic configuration for a given component
+   * based on its host element.
+   *
+   * @param {HTMLElement} host - The `host` parameter is an HTMLElement that represents the component for
+   * which we want to retrieve the semantics.
+   * @returns {Nullable<EventSemantics>} a value of type `Nullable<EventSemantics>`.
+   */
+  getSemanticsInComponents(host) {
+    const componentName = host.tagName.toLocaleLowerCase();
+    if (this.config.components &&
+      Object.prototype.hasOwnProperty.call(this.config.components, componentName)) {
+      return this.config.components[componentName];
+    }
+    return null;
+  }
+}
+const internalVegaEventManager = new InternalVegaEventManager();
+
+export { BaseStrategy as B, internalVegaEventManager as i, jqueryDelegatedStrategyController as j };

package/dist/esm/keyboard-manager-1846c6a5.js

@@ -0,0 +1,146 @@
+import { b as isParent, e as getDeepActiveElementInShadow } from './ui-ba5a4758.js';
+import { i as isNonNullable } from './type-guard-23a08026.js';
+
+/**
+ * It listens to the keyup event on the window and calls the appropriate method on the registered elements
+ *
+ * @property {KeyboardEventListener[]} listeners used to record listeners
+ */
+class KeyboardManager {
+  /**
+   * Manager init
+   */
+  constructor() {
+    this.listeners = [];
+    this.listenKeyPress();
+  }
+  /**
+   * Add the given listener to the list of listeners.
+   *
+   * @param {KeyboardEventListener[]} listeners - The listener to register.
+   * @returns {void}
+   */
+  register(listeners) {
+    listeners.map((listener) => (listener.eventName || (listener.eventName = 'keyup')));
+    this.listeners = this.listeners.concat(listeners);
+  }
+  /**
+   * The function removes the listeners from the listeners array
+   *
+   * @param {KeyboardEventListener[]} listeners - KeyboardEventListener[]
+   * @returns {void}
+   */
+  deregister(listeners) {
+    this.listeners = this.listeners.filter((listener) => !listeners.includes(listener));
+  }
+  /**
+   * > Listen for keyup events on the window, and if the code matches the keyCode of a listener,
+   * invoke the listener's callback
+   */
+  listenKeyPress() {
+    // eslint-disable-next-line no-restricted-globals
+    document.addEventListener('keydown', (e) => {
+      this.invokeListeners('keydown', e);
+    });
+    // listen keyup is waiting activeElement changed.
+    // eslint-disable-next-line no-restricted-globals
+    document.addEventListener('keyup', (e) => {
+      this.invokeListeners('keyup', e);
+    });
+  }
+  /**
+   * We filter the listeners by the event name, then filter them by whether the key code matches the
+   * listener's key code, and then invoke the callback function for each listener that matches
+   *
+   * @param {'keyup' | 'keydown'} eventName - The name of the event that was triggered.
+   * @param {KeyboardEvent} event - KeyboardEvent - this is the event that is passed to the event
+   * listener.
+   */
+  invokeListeners(eventName, event) {
+    this.listeners
+      .filter((listener) => listener.eventName === eventName && this.shouldInvokeListener(listener, event))
+      .forEach((listener) => {
+      if (listener.preventDefault) {
+        event.preventDefault();
+      }
+      listener.callback(event);
+    });
+  }
+  /**
+   * > If the keyCode is accepted, and the activeElement is in the scope, and the activeElement is not
+   * out of the scope, then invoke the listener
+   *
+   * @param {KeyboardEventListener} listener - KeyboardEventListener - the listener object that we're
+   * checking
+   * @param {KeyboardEvent} event - The keyboard event that triggered the listener.
+   * @returns {boolean} - should invoke
+   */
+  shouldInvokeListener(listener, event) {
+    let keyCode = '';
+    if (event.code) {
+      keyCode = event.code;
+    }
+    else if (event.key && event.key !== 'Unidentified') {
+      keyCode = event.key;
+    }
+    let activeElementInScope = [];
+    let activeElementOutScope = [];
+    const isKeyCodeAccepted = Array.isArray(listener.keyCode)
+      ? listener.keyCode.includes(keyCode)
+      : listener.keyCode === keyCode;
+    if (!isKeyCodeAccepted) {
+      return false;
+    }
+    /* istanbul ignore next */
+    if (typeof listener.activeElementInScope === 'function') {
+      activeElementInScope = listener.activeElementInScope();
+    }
+    else if (typeof listener.activeElementInScope === 'object') {
+      activeElementInScope = listener.activeElementInScope;
+    }
+    /* istanbul ignore next */
+    if (typeof listener.activeElementOutScope === 'function') {
+      activeElementOutScope = listener.activeElementOutScope();
+    }
+    else if (typeof listener.activeElementOutScope === 'object') {
+      activeElementOutScope = listener.activeElementOutScope;
+    }
+    const isActiveElementInScope = listener.activeElementInScope
+      ? activeElementInScope.some((element) => {
+        // eslint-disable-next-line no-restricted-globals
+        return isParent(getDeepActiveElementInShadow(document, true), element);
+      })
+      : true;
+    if (!isActiveElementInScope) {
+      return false;
+    }
+    const isActiveElementOutScope = listener.activeElementOutScope
+      ? activeElementOutScope.every((element) => 
+      // eslint-disable-next-line no-restricted-globals
+      !isParent(getDeepActiveElementInShadow(document, true), element))
+      : true;
+    const isExpectedModifierPressed = isNonNullable(listener.modifierPressed)
+      ? listener.modifierPressed === this.isModifierPressed(event)
+      : true;
+    const isExpectedShiftKeyPressed = isNonNullable(listener.shiftKey)
+      ? listener.shiftKey === event.shiftKey
+      : true;
+    return (isKeyCodeAccepted &&
+      isActiveElementInScope &&
+      isActiveElementOutScope &&
+      isExpectedModifierPressed &&
+      isExpectedShiftKeyPressed);
+  }
+  /**
+   * Checks if the platform modifier key (Meta on Mac, Ctrl on Windows) is pressed.
+   *
+   * @param {KeyboardEvent} e - The keyboard event to check.
+   * @returns {boolean} - True if the platform modifier key is pressed, false otherwise.
+   */
+  isModifierPressed(e) {
+    return /Mac|iPhone|iPad/.test(navigator.userAgent) ? e.metaKey : e.ctrlKey;
+  }
+}
+const KeyboardManager$1 = new KeyboardManager();
+
+export { KeyboardManager$1 as K };

package/dist/esm/keyboard-manager-slimmer-1ae0aa4d.js

@@ -0,0 +1,37 @@
+import { M as MapToComponentMethod, V as VegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
+import { K as KeyboardManager } from './keyboard-manager-1846c6a5.js';
+
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+class KeyboardManagerSlimmer extends VegaSlimmer {
+  constructor(listenersRetriever) {
+    super();
+    this.keyboardEventListeners = [];
+    this.listenersRetriever = listenersRetriever;
+  }
+  connectedCallback() {
+    KeyboardManager.register(this.keyboardEventListeners);
+  }
+  disconnectedCallback() {
+    KeyboardManager.deregister(this.keyboardEventListeners);
+  }
+  componentDidLoad() {
+    this.keyboardEventListeners = this.listenersRetriever(this);
+    KeyboardManager.register(this.keyboardEventListeners);
+  }
+}
+__decorate([
+  MapToComponentMethod('connectedCallback')
+], KeyboardManagerSlimmer.prototype, "connectedCallback", null);
+__decorate([
+  MapToComponentMethod('disconnectedCallback')
+], KeyboardManagerSlimmer.prototype, "disconnectedCallback", null);
+__decorate([
+  MapToComponentMethod('componentDidLoad')
+], KeyboardManagerSlimmer.prototype, "componentDidLoad", null);
+
+export { KeyboardManagerSlimmer as K };