@heartlandone/vega 2.79.0 → 2.81.0

package/dist/esm/image-annotation-action-6048d32e.js

@@ -0,0 +1,280 @@
+import { h } from './index-090d31ca.js';
+import { V as VegaInternalIconManager } from './internal-icon-manager-bd80b3bb.js';
+import { c as MapToComponentField, V as VegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
+import { A as ActionHandleStrategyRegistry, _ as RTE_TEXT_COLORS, c as RTETextNode, ag as TextColorAnnotationAction, F as NodeAnnotationTypeEnum, m as AnnotationAction } from './code-block-cd913077.js';
+import { D as DomNodeSubjectObserverFactory } from './dom-node-subject-observer-factory-aca0116e.js';
+import { a as VegaClick, b as VegaPopoverShow, c as VegaPopoverHide, h as VegaChange } from './vega-event-id-4ede557a.js';
+import { a as VegaDarkModeStyleController } from './dark-mode-style-controller-82e5c1c6.js';
+import { g as ImageAnnotation } from './content-state-89f8eecb.js';
+
+const text = {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><!--! Font Awesome Pro 6.3.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><path fill="currentColor" d="M64 96v32c0 17.7-14.3 32-32 32s-32-14.3-32-32V80C0 53.5 21.5 32 48 32H224 400c26.5 0 48 21.5 48 48v48c0 17.7-14.3 32-32 32s-32-14.3-32-32V96H256l0 320h48c17.7 0 32 14.3 32 32s-14.3 32-32 32H144c-17.7 0-32-14.3-32-32s14.3-32 32-32h48l0-320H64z"/></svg>`,
+};
+
+var __decorate$2 = (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 ToolbarButtonSlimmer extends VegaSlimmer {
+  constructor({ icon, tooltip, autoFocusOnClick = true }) {
+    super();
+    this.renderBtn = ({ showArrowIcon, iconColor } = {}) => {
+      var _a;
+      return (h("vega-tooltip", { text: this.translationSlimmer.t(this.tooltip.text), placement: ['bottom', 'top'] },
+        h("vega-rich-text-editor-toolbar-button", Object.assign({ showArrowIcon: showArrowIcon, icon: this.icon, iconColor: iconColor, ref: (ref) => {
+            DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaClick, () => {
+              this.handleClick();
+            });
+          }, selected: this.isSelected(), disabled: this.isDisabled(), hidden: this.isHidden() }, this.preventLostFocus()), (_a = this.renderSlotContent) === null || _a === void 0 ? void 0 : _a.call(this))));
+    };
+    /**
+     * Handle the click event on the toolbar button.
+     * If there are no selected nodes, the focus will be set on the content and the click will be triggered after the selection change.
+     */
+    this.handleClick = () => {
+      if (typeof this.onClick === 'function') {
+        const selectedNodes = this.selectionController.getSelectedNodes();
+        if (!selectedNodes.length && this.autoFocusOnClick) {
+          void this.focusController.focusOnLastTextNode().then(() => {
+            this.onClick();
+          });
+        }
+        else {
+          this.onClick();
+        }
+      }
+    };
+    this.icon = icon;
+    this.tooltip = tooltip;
+    this.autoFocusOnClick = autoFocusOnClick;
+  }
+  setIcon(icon) {
+    this.icon = icon;
+  }
+  /**
+   * Whether the button is hidden or not.
+   */
+  isHidden() {
+    return false;
+  }
+  render() {
+    return typeof this.renderBtnWrapper === 'function'
+      ? this.renderBtnWrapper(this.renderBtn)
+      : this.renderBtn();
+  }
+  /**
+   * Whether the button is disabled or not.
+   */
+  isDisabled() {
+    return this.disabled;
+  }
+  preventLostFocus() {
+    return {
+      onMouseDown: (e) => e.preventDefault(),
+    };
+  }
+}
+__decorate$2([
+  MapToComponentField()
+], ToolbarButtonSlimmer.prototype, "translationSlimmer", void 0);
+__decorate$2([
+  MapToComponentField()
+], ToolbarButtonSlimmer.prototype, "selectionController", void 0);
+__decorate$2([
+  MapToComponentField()
+], ToolbarButtonSlimmer.prototype, "focusController", void 0);
+__decorate$2([
+  MapToComponentField()
+], ToolbarButtonSlimmer.prototype, "disabled", void 0);
+
+var __decorate$1 = (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;
+};
+/**
+ * Abstract class for visual mode toolbar buttons, except for the source edit button.
+ */
+class VisualModeToolbarButtonSlimmer extends ToolbarButtonSlimmer {
+  constructor(config) {
+    super(config);
+  }
+  /**
+   * Determines if the button should be hidden.
+   * Hide the button when the editor is in source view mode, except for the source edit button.
+   *
+   * @returns {boolean} - True if the button is hidden, false otherwise.
+   */
+  isHidden() {
+    return this.sourceView;
+  }
+  /**
+   * Determines if the button should be disabled.
+   * Determines whether should disable the button or not when the editor is not in source view mode, except for the source edit button.
+   *
+   * @returns {boolean} - True if the button is disabled, false otherwise.
+   */
+  isDisabled() {
+    return super.isDisabled() && !this.sourceView;
+  }
+  /**
+   * Check if the node support text annotation
+   *
+   * @param {Nullable< RTENode| RTEBlock>} node - The RTE node to check
+   * @param {string} annotationActionName - The annotation name to check
+   * @returns {boolean} - True if the node support text annotation, false otherwise
+   */
+  shouldDisabledToolbar(node, annotationActionName) {
+    return node && !ActionHandleStrategyRegistry.canHandle(annotationActionName, node);
+  }
+}
+__decorate$1([
+  MapToComponentField()
+], VisualModeToolbarButtonSlimmer.prototype, "sourceView", void 0);
+
+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 TextColorToolbarButtonSlimmer extends VisualModeToolbarButtonSlimmer {
+  constructor() {
+    super({
+      icon: 'text',
+      tooltip: { text: 'Text Color' },
+    });
+    this.popoverShow = false;
+    VegaDarkModeStyleController.registerCustomDarkModeColor(TextColorToolbarButtonSlimmer.formatDarkModeColor());
+  }
+  static formatDarkModeColor() {
+    return RTE_TEXT_COLORS.reduce((prev, current) => {
+      current.dark && (prev[`rich-text-editor-${current.key}`] = current.dark);
+      return prev;
+    }, {});
+  }
+  renderSlotContent() {
+    return (h("div", { class: {
+        'toolbar-btn-color-preview-box': true,
+        'disabled': this.isDisabled(),
+      }, style: {
+        backgroundColor: this.getCurrentColor(),
+      } }));
+  }
+  handlePopoverShowChange() {
+    this.popoverShow = true;
+  }
+  handlePopoverHideChange() {
+    this.popoverShow = false;
+  }
+  renderBtnWrapper(renderBtn) {
+    return (h("vega-popover", { placement: "bottom", alignment: "center", ref: (ref) => {
+        this.popoverRef = ref;
+        DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaPopoverShow, this.handlePopoverShowChange.bind(this));
+        DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaPopoverHide, this.handlePopoverHideChange.bind(this));
+      } },
+      h("div", { slot: "popover-content" }, renderBtn({
+        showArrowIcon: false,
+      })),
+      h("div", Object.assign({ slot: "popover", style: { userSelect: 'none' } }, super.preventLostFocus()), this.renderPopoverContent())));
+  }
+  renderPopoverContent() {
+    return (h("vega-color-picker", { isInline: true, colors: RTE_TEXT_COLORS.map((item) => item[!this.isInDarkMode ? 'light' : 'dark']), ref: (ref) => {
+        DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaChange, this.handleChange.bind(this));
+      }, value: this.getCurrentColor() }));
+  }
+  async handleChange(e) {
+    if (this.popoverShow) {
+      if (!this.selectionController.getSelectedNodes().length) {
+        await this.focusController.focusOnLastTextNode();
+      }
+      this.selectionController
+        .getSelectedNodes()
+        .filter((node) => node instanceof RTETextNode)
+        .forEach((node) => node.apply(new TextColorAnnotationAction(this.matchColor(e.detail).key)));
+    }
+    void this.popoverRef.hide();
+  }
+  matchColor(value) {
+    return RTE_TEXT_COLORS.find((item) => item[this.isInDarkMode ? 'dark' : 'light'] === value);
+  }
+  getCurrentColor() {
+    let selectedItem = RTE_TEXT_COLORS[0];
+    const selectedNodes = this.selectionController.getSelectedNodes();
+    if (selectedNodes.length > 1) {
+      if (this.isSelectedSameColor(selectedNodes)) {
+        selectedItem = this.getTextColor(selectedNodes[0]);
+      }
+      else {
+        selectedItem = null;
+      }
+    }
+    if (selectedNodes.length === 1) {
+      selectedItem = this.getTextColor(selectedNodes[0]);
+    }
+    return selectedItem ? selectedItem[!this.isInDarkMode ? 'light' : 'dark'] : null;
+  }
+  isSelected() {
+    return false;
+  }
+  isSelectedSameColor(selectedNodes) {
+    return selectedNodes.every((node) => this.getTextColor(node).key === this.getTextColor(selectedNodes[0]).key);
+  }
+  getTextColor(selectedNodes) {
+    var _a;
+    return (((_a = selectedNodes.getAnnotationByType('TEXT_COLOR')) === null || _a === void 0 ? void 0 : _a.textColor) ||
+      RTE_TEXT_COLORS[0]);
+  }
+  isDisabled() {
+    const selectedNodes = this.selectionController.getSelectedNodes();
+    return (super.isDisabled() ||
+      selectedNodes.some((node) => {
+        var _a;
+        return ((_a = node.getAnnotationByType(NodeAnnotationTypeEnum.CODE)) === null || _a === void 0 ? void 0 : _a.code) ||
+          node.getAnnotationByType(NodeAnnotationTypeEnum.LINK) ||
+          this.shouldDisabledToolbar(node, TextColorAnnotationAction.name);
+      }));
+  }
+}
+(() => {
+  VegaInternalIconManager.register({
+    text,
+  });
+})();
+__decorate([
+  MapToComponentField()
+], TextColorToolbarButtonSlimmer.prototype, "host", void 0);
+__decorate([
+  MapToComponentField()
+], TextColorToolbarButtonSlimmer.prototype, "isInDarkMode", void 0);
+__decorate([
+  MapToComponentField()
+], TextColorToolbarButtonSlimmer.prototype, "selectionController", void 0);
+__decorate([
+  MapToComponentField()
+], TextColorToolbarButtonSlimmer.prototype, "focusController", void 0);
+
+/**
+ * Action to add an image annotation to the editor
+ */
+class ImageAnnotationAction extends AnnotationAction {
+  constructor(size, alt) {
+    super();
+    this.isFlushable = true;
+    this.size = size;
+    this.alt = alt;
+  }
+  /**
+   * Converts the action to an annotation
+   *
+   * @returns {ImageAnnotation} The annotation
+   */
+  toAnnotation() {
+    return new ImageAnnotation(this.size, this.alt);
+  }
+}
+
+export { ImageAnnotationAction as I, TextColorToolbarButtonSlimmer as T, VisualModeToolbarButtonSlimmer as V, ToolbarButtonSlimmer as a };

package/dist/esm/index.js

@@ -1,36 +1,36 @@
 export { g as getCurrentBreakpoint } from './breakpoints-332702ed.js';
 export { L as LogUtility, s as setVegaLogLevel } from './global-slimmer-registry-17c4efd4.js';
-export { d as formatAndValidBackgroundColor, e as formatAndValidBorderColor, g as formatAndValidBorderRadius, c as formatAndValidBreakpointSize, a as formatAndValidGap, h as formatAndValidPadding, f as formatAndValidResponsiveToken, b as formatAndValidShadow, i as formatAndValidTextColor } from './design-token-9c4eb6b1.js';
+export { d as formatAndValidBackgroundColor, e as formatAndValidBorderColor, g as formatAndValidBorderRadius, c as formatAndValidBreakpointSize, a as formatAndValidGap, h as formatAndValidPadding, f as formatAndValidResponsiveToken, b as formatAndValidShadow, i as formatAndValidTextColor } from './design-token-7566d54c.js';
 export { c as camelToDashCase } from './string-a953eafc.js';
-export { d as BackgroundColorMap, a as BackgroundColors, e as BorderColorMap, b as BorderColors, B as BorderRadius, C as Colors, F as FillBackgroundColors, g as ShadowMap, f as Shadows, h as Spacing, S as StrokeBackgroundColors, c as TextColorMap, T as TextColors } from './type-guard-c20cbbff.js';
+export { d as BackgroundColorMap, a as BackgroundColors, e as BorderColorMap, b as BorderColors, B as BorderRadius, C as Colors, F as FillBackgroundColors, g as ShadowMap, f as Shadows, h as Spacing, S as StrokeBackgroundColors, c as TextColorMap, T as TextColors } from './type-guard-f6c9c89d.js';
 export { B as Breakpoints } from './breakpoints-d9faf11c.js';
 export { I as Icons, g as getIconFromToken } from './icons-8627925e.js';
 export { b as Typography, a as TypographyKeys, T as TypographyUrls } from './typography-396de03f.js';
 export { d as BoxDisplay, e as BreakpointKeys, C as CssStates, F as FlexDirections } from './ui-93922c59.js';
 export { F as FrameworkEnum, v as VegaEnvManager } from './vega-env-manager-8f8dc473.js';
-export { A as ActionHandlerInterceptor, I as InsertNodeToNearestRootAction, o as RTELanguageToolbarButtonRenderer, m as RTETokenNode, n as RTETokenNodeRenderer, R as RTETokenToolbarButtonRenderer, b as VegaEventManager, V as VegaLoader, a as VegaNotify, j as VegaRTEExtension, k as VegaRTEExtensionRenderer, h as VegaRTEFunctionExtension, g as VegaRTELanguageExtension, i as VegaRTETableExtension, f as VegaRTETokenExtension, l as VegaRTEToolbarButtonRenderer, d as VegaSkeletonLoader, e as VegaTranslation, c as VegaZIndexManager, w as waitForVega } from './token-extension-612575cb.js';
+export { A as ActionHandlerInterceptor, I as InsertNodeToNearestRootAction, o as RTELanguageToolbarButtonRenderer, m as RTETokenNode, n as RTETokenNodeRenderer, R as RTETokenToolbarButtonRenderer, b as VegaEventManager, V as VegaLoader, a as VegaNotify, j as VegaRTEExtension, k as VegaRTEExtensionRenderer, h as VegaRTEFunctionExtension, g as VegaRTELanguageExtension, i as VegaRTETableExtension, f as VegaRTETokenExtension, l as VegaRTEToolbarButtonRenderer, d as VegaSkeletonLoader, e as VegaTranslation, c as VegaZIndexManager, w as waitForVega } from './token-extension-5ee7a3f1.js';
 export { F as FeatureFlag } from './feature-flag-controller-30f7b625.js';
-export { V as VegaThemeManager } from './split-cell-operation-55cd9fae.js';
+export { V as VegaThemeManager } from './split-cell-operation-548ea374.js';
 export { V as VegaDialog } from './vega-dialog-controller-bbb2fc52.js';
 export { B as VegaJQueryDelegatedEventStrategy } from './internal-vega-event-manager-59f5bd47.js';
 export { V as VegaIconManager } from './icon-manager-539d7cf7.js';
-export { V as ValidCreditCardNumberRule } from './valid-credit-card-number-rule-b9c3c2f8.js';
-import './ui-ac244bf0.js';
+export { V as ValidCreditCardNumberRule } from './valid-credit-card-number-rule-3bf19ad6.js';
+import './ui-b7600a48.js';
 export { s as VegaTranslationResourceEN } from './internal-translation-controller-b08aa9ab.js';
 export { s as setVegaNonce } from './vega-nonce-manager-497e5eb5.js';
-export { f as ActionHandleStrategy, g as AppendChildrenAction, W as CodeLanguage, n as CustomAttributeAnnotation, y as CustomClassAnnotation, x as CustomStyleAnnotation, I as InsertChildrenAfterAction, i as InsertChildrenBeforeAction, M as ModifyContentAction, k as ModifyContentActionType, e as RTEAnnotationStyle, c as RTEBlock, E as RTEDecoratorNode, h as RTENode, d as RTETextBlock, b as RTETextNode, m as RemoveChildrenAction, V as VegaRTEPresetToolbarItems } from './code-block-58d1dbe5.js';
-export { B as BlockToRTEBlockStrategyAbstract, a as ElementToDTOStrategy, I as InsertNewParagraphAction, b as RTEImageBlock, f as RTEImageNode, e as RTEListBlock, d as RTEListItemBlock, U as UpdateCursorPositionAction, V as VegaRTEContent, h as htmlElementToAnnotationGenerator } from './content-state-dad1fd71.js';
-export { G as GridColumns, a as GridRows } from './responsive-format-facade-e8534e59.js';
+export { g as ActionHandleStrategy, h as AppendChildrenAction, ab as CodeLanguage, o as CustomAttributeAnnotation, D as CustomClassAnnotation, z as CustomStyleAnnotation, I as InsertChildrenAfterAction, j as InsertChildrenBeforeAction, M as ModifyContentAction, l as ModifyContentActionType, f as RTEAnnotationStyle, d as RTEBlock, G as RTEDecoratorNode, p as RTEFilterStylesStrategy, i as RTENode, e as RTETextBlock, c as RTETextNode, n as RemoveChildrenAction, V as VegaRTEPresetToolbarItems } from './code-block-cd913077.js';
+export { B as BlockToRTEBlockStrategyAbstract, a as ElementToDTOStrategy, I as InsertNewParagraphAction, b as RTEImageBlock, f as RTEImageNode, e as RTEListBlock, d as RTEListItemBlock, U as UpdateCursorPositionAction, V as VegaRTEContent, h as htmlElementToAnnotationGenerator } from './content-state-89f8eecb.js';
+export { G as GridColumns, a as GridRows } from './responsive-format-facade-151dbd10.js';
 export { C as CheckBoxRequiredRule } from './check-box-required-rule-cb0aa339.js';
-export { D as DateRequiredRule } from './date-required-rule-4c40a4eb.js';
+export { D as DateRequiredRule } from './date-required-rule-2b08f32c.js';
 export { I as InputPhoneNumberRequiredRule } from './input-phone-number-required-rule-be6a5572.js';
 export { I as InputRangeRequiredRule } from './input-range-required-rule-3ad74776.js';
 export { R as RequiredFieldRule } from './required-field-rule-ab4bdc47.js';
-export { R as RichTextEditorRequiredRule } from './rich-text-editor-required-rule-c391aeb6.js';
-export { T as TimeRangeRequiredRule, a as TimeRequiredRule } from './time-required-rule-2569e5ad.js';
+export { R as RichTextEditorRequiredRule } from './rich-text-editor-required-rule-1fc7c040.js';
+export { T as TimeRangeRequiredRule, a as TimeRequiredRule } from './time-required-rule-3f5a8822.js';
 export { T as ToggleSwitchRequiredRule } from './toggle-switch-required-rule-b3cf4302.js';
 export { F as FileUploaderRequiredRule } from './file-uploader-required-rule-ad886d01.js';
-export { R as RTERange } from './range-4f9bf69d.js';
+export { R as RTERange } from './range-b76edec7.js';
 import './misc-9fdbcfbb.js';
 import './create-public-api-runtime-metrics-slimmer-aaadaa08.js';
 import './dynamic-slimmer-90b8af32.js';
@@ -41,12 +41,12 @@ import './try-get-document-bef0f526.js';
 import './dto-renderer-manager-12bc9121.js';
 import './base-renderer-101f6d04.js';
 import './internal-icon-manager-bd80b3bb.js';
-import './dom-node-subject-observer-factory-94b2e2c3.js';
+import './dom-node-subject-observer-factory-aca0116e.js';
 import './change-manager-6a7eb88c.js';
 import './observer-3959f9dd.js';
 import './vega-event-id-4ede557a.js';
 import './remote-invocation-registry-d69245c2.js';
-import './vega-internal-event-id-8002b179.js';
+import './vega-internal-event-id-70bd893d.js';
 import './dark-mode-style-controller-82e5c1c6.js';
 import './static-subject-title-52f93124.js';
 import './index-3b327f29.js';

package/dist/esm/inject-keyboard-manager-c6557f50.js

@@ -0,0 +1,35 @@
+import { K as KeyboardManager } from './keyboard-manager-c7b125d7.js';
+
+/**
+ * It takes a function that returns an array of keyboard event listeners, and returns a decorator
+ * function that takes a component class and a property name, and registers the listeners returned by
+ * the function with the keyboard manager when the component is loaded, and remove registers them when the
+ * component is disconnected
+ *
+ * @param {(instance: ComponentInterface) => KeyboardEventListener[]} listenersRetriever - (instance: ComponentInterface) => KeyboardEventListener[]
+ * @returns {(target: ComponentInterface, key: string) => void} A decorator function that takes a component class and a property name.
+ */
+function InjectKeyboardManager(listenersRetriever) {
+  /* A decorator function that takes a component class and a property name. */
+  return (componentClass) => {
+    const { connectedCallback, componentDidLoad, disconnectedCallback } = componentClass;
+    /* eslint-disable jsdoc/require-jsdoc */
+    componentClass.connectedCallback = function () {
+      const { keyboardEventListeners = [] } = this;
+      KeyboardManager.register(keyboardEventListeners);
+      return connectedCallback === null || connectedCallback === void 0 ? void 0 : connectedCallback.call(this);
+    };
+    componentClass.componentDidLoad = function () {
+      this.keyboardEventListeners = listenersRetriever(this);
+      KeyboardManager.register(this.keyboardEventListeners);
+      return componentDidLoad === null || componentDidLoad === void 0 ? void 0 : componentDidLoad.call(this);
+    };
+    componentClass.disconnectedCallback = function () {
+      const { keyboardEventListeners = [] } = this;
+      KeyboardManager.deregister(keyboardEventListeners);
+      return disconnectedCallback === null || disconnectedCallback === void 0 ? void 0 : disconnectedCallback.call(this);
+    };
+  };
+}
+
+export { InjectKeyboardManager as I };

package/dist/esm/keyboard-manager-c7b125d7.js

@@ -0,0 +1,146 @@
+import { b as isParent, e as getDeepActiveElementInShadow } from './ui-b7600a48.js';
+import { i as isNonNullable } from './type-guard-f6c9c89d.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-6109039b.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-c7b125d7.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 };