@globalpayments/vega 2.95.0 → 2.97.0

package/dist/collection/components/vega-rich-text-editor/dto/content-state.js

@@ -24,6 +24,7 @@ import { LogUtility } from '../../../utils/log';
 import { HTMLContentCleaner } from '../slimmers/controllers/html-cleaner';
 import { RTEFilterStylesStrategyRegistry } from './filter-styles-strategies/filter-styles-strategy-registry';
 import { DeleteSelectedContentStrategy } from './action-handle-strategies/modify-content-strategies/delete-selected-content-strategy';
+import { ReplaceNestListAction } from './actions/replace-nest-list-action';
 /**
  * Class representing the content state of the rich text editor.
  */
@@ -191,14 +192,19 @@ export class VegaRTEContent {
   /**
    * Convert text to list.
    *
-   * @param {RTETextBlock} block - block
+   * @param {RTETextBlock | RTEListItemBlock} block - Block to convert or rebuild.
    * @returns {RTEListItemBlock} list item block dto.
    */
   toListItem(block) {
+    var _a;
     block.children.map((node) => node.apply(new SyncUpSelectionAction()));
     const listItemBlock = new RTEListItemBlock(generateUUID());
     listItemBlock.apply(new AppendChildrenAction(block['children']));
     listItemBlock['annotationMap'] = block['annotationMap'];
+    if (block instanceof RTEListItemBlock && ((_a = block.nestList) === null || _a === void 0 ? void 0 : _a.length)) {
+      listItemBlock.apply(new ReplaceNestListAction([...block.nestList]));
+      block.apply(new ReplaceNestListAction([]));
+    }
     return listItemBlock;
   }
   /**

package/dist/collection/components/vega-rich-text-editor/dto/filter-styles-strategies/list-block/list-block-filter-styles-strategy.js

@@ -27,10 +27,14 @@ export class ListBlockFilterStylesStrategy extends RTEFilterStylesStrategy {
    * @inheritDoc
    */
   toCssText() {
-    const selector = this.elementTagName
-      .split(',')
-      .map((tag) => `.${RTEFilterStylesStrategy.RTE_CONTENT_CONTAINER_CLASS_NAME} ${tag.trim()}`)
+    const containerClass = RTEFilterStylesStrategy.RTE_CONTENT_CONTAINER_CLASS_NAME;
+    const tags = this.elementTagName.split(',').map((tag) => tag.trim());
+    const baseSelector = tags.map((tag) => `.${containerClass} ${tag}`).join(', ');
+    const markerSelector = tags
+      .map((tag) => `.${containerClass} ${tag} > li::marker`)
       .join(', ');
-    return `${selector} { ${this.convertStylesMapToCssText(this.stylesToBeFiltered)} }`;
+    const markerStyles = this.convertStylesMapToCssText(ListAnnotation.getDefaultMarkerStyles());
+    return (`${baseSelector} { ${this.convertStylesMapToCssText(this.stylesToBeFiltered)} } ` +
+      `${markerSelector} { ${markerStyles} }`);
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/renderers/blocks/link-wrapper-renderer.js

@@ -19,12 +19,33 @@ class RTELinkWrapperRenderer {
     this.handleChange = ({ detail }, textFromNodes, linkNodes) => {
       switch (detail.action) {
         case 'link': {
-          const { url, text } = detail.payload;
+          const { url, text, linkType } = detail.payload;
           const textChanged = text !== textFromNodes;
           linkNodes.forEach((node) => {
-            const groupKey = node.getAnnotationByType(NodeAnnotationTypeEnum.LINK).link.groupKey;
+            const currentLinkAnnotation = node.getAnnotationByType(NodeAnnotationTypeEnum.LINK);
+            const groupKey = currentLinkAnnotation.link.groupKey;
+            const nextCustomAttribute = Object.assign({}, (currentLinkAnnotation.link.customAttribute || {}));
+            if (linkType) {
+              nextCustomAttribute['data-link-type'] = linkType;
+            }
+            else {
+              delete nextCustomAttribute['data-link-type'];
+            }
+            const nextLink = {
+              href: url,
+              groupKey: groupKey,
+            };
+            if (Object.keys(nextCustomAttribute).length > 0) {
+              nextLink.customAttribute = nextCustomAttribute;
+            }
+            if (currentLinkAnnotation.link.customClass) {
+              nextLink.customClass = currentLinkAnnotation.link.customClass;
+            }
+            if (currentLinkAnnotation.link.customStyle) {
+              nextLink.customStyle = currentLinkAnnotation.link.customStyle;
+            }
             const linkAnnotationAction = new LinkAnnotationAction({
-              link: { href: url, groupKey: groupKey },
+              link: nextLink,
               newText: textChanged ? text : undefined,
               needMergeNode: textChanged && linkNodes.length > 1,
               doSplit: false,
@@ -106,6 +127,7 @@ class RTELinkWrapperRenderer {
     return Array.isArray(item);
   }
   renderLinkEditorWrapper(linkNodes, linkAnnotation, linkGroupAnnotation) {
+    var _a;
     const { href } = linkAnnotation.link;
     const textFromNodes = linkNodes.map((node) => node.text).join('');
     let linkWrapperRef;
@@ -117,6 +139,7 @@ class RTELinkWrapperRenderer {
       } },
       this.renderLink(linkNodes, linkAnnotation, linkGroupAnnotation),
       h("vega-rich-text-link-editor", { record: {
+          linkType: (_a = linkAnnotation.link.customAttribute) === null || _a === void 0 ? void 0 : _a['data-link-type'],
           text: textFromNodes,
           url: href,
         }, ref: (ref) => {

package/dist/collection/components/vega-rich-text-editor/dto/renderers/blocks/list-block-renderer.js

@@ -1,10 +1,43 @@
 import { h } from '@stencil/core';
+import { RTEListItemBlock } from '../../blocks/list-item-block';
 import { RTEBlockRenderer } from './block-renderer.abstract';
 import RTEListItemBlockRenderer from './list-item-block-renderer';
+const defaultOrderedListMarkerRule = ['decimal', 'lower-alpha', 'lower-roman'];
+const defaultBulletListMarkerRule = ['disc', 'circle', 'square'];
 class RTEListBlockRenderer extends RTEBlockRenderer {
   render(block, renderContext) {
     const BlockTag = block.getBlockTag();
-    return (h(BlockTag, Object.assign({}, this.getCustomAttrs(block), { key: block.id, ref: (ref) => super.registerRef(ref, block), style: block.getStyles(), class: block.getClasses() }), block.children.map((listItemBlock) => RTEListItemBlockRenderer.render(listItemBlock, renderContext))));
+    const styles = block.getStyles(renderContext);
+    const resolvedListMarker = this.resolveListMarker(block, styles);
+    if (resolvedListMarker) {
+      styles.listStyleType = resolvedListMarker;
+    }
+    return (h(BlockTag, Object.assign({}, this.getCustomAttrs(block), { key: block.id, ref: (ref) => super.registerRef(ref, block), style: styles, class: block.getClasses() }), block.children.map((listItemBlock) => RTEListItemBlockRenderer.render(listItemBlock, renderContext))));
+  }
+  resolveListMarker(block, styles) {
+    if (styles.listStyleType || styles['list-style-type']) {
+      return undefined;
+    }
+    const depth = this.getListDepth(block, block.type);
+    if (block.type === 'number-list') {
+      return defaultOrderedListMarkerRule[depth % defaultOrderedListMarkerRule.length];
+    }
+    if (block.type === 'bullet-list') {
+      return defaultBulletListMarkerRule[depth % defaultBulletListMarkerRule.length];
+    }
+    return undefined;
+  }
+  getListDepth(block, targetType) {
+    let depth = 0;
+    let currentList = block;
+    while (currentList.parent instanceof RTEListItemBlock) {
+      const parentList = currentList.parent.parent;
+      if (parentList.type === targetType) {
+        depth++;
+      }
+      currentList = parentList;
+    }
+    return depth;
   }
 }
 export default new RTEListBlockRenderer();

package/dist/collection/components/vega-rich-text-editor/dto/renderers/blocks/list-item-block-renderer.js

@@ -3,9 +3,26 @@ import RTEListBlockRenderer from './list-block-renderer';
 import { RTEBlockTextNodesRenderer } from './block-text-nodes-renderer.abstract';
 class RTEListItemBlockRenderer extends RTEBlockTextNodesRenderer {
   render(block, renderContext) {
-    return (h("li", Object.assign({}, this.getCustomAttrs(block), { key: block.id, ref: (ref) => super.registerRef(ref, block), style: block.getStyles(), class: block.getClasses() }),
-      super.renderNodes(block, renderContext),
-      this.renderChildren(block.nestList, renderContext)));
+    var _a;
+    const hasNestList = ((_a = block.nestList) === null || _a === void 0 ? void 0 : _a.length) > 0;
+    return (h("li", Object.assign({}, this.getCustomAttrs(block), { key: this.getRenderKey(block), ref: (ref) => super.registerRef(ref, block), style: block.getStyles(), class: block.getClasses() }),
+      hasNestList ? (
+      // Keep text nodes wrapped as a block-level element when a nested list exists.
+      // This preserves stable marker/text flow and selection behavior before the child list.
+      h("span", { style: { display: 'block' } }, super.renderNodes(block, renderContext))) : (super.renderNodes(block, renderContext)),
+      hasNestList && this.renderChildren(block.nestList, renderContext)));
+  }
+  /**
+   * Include structural ownership and direct nested-list identity in the key so
+   * list mutations recreate the li when its rendered child shape changes.
+   *
+   * @param {RTEListItemBlock} block - List item being rendered.
+   * @returns {string} Structure-aware render key.
+   */
+  getRenderKey(block) {
+    var _a;
+    const nestListIds = ((_a = block.nestList) !== null && _a !== void 0 ? _a : []).map((list) => list.id);
+    return JSON.stringify([block.parent.id, block.id, nestListIds]);
   }
   renderChildren(children, renderContext) {
     return children === null || children === void 0 ? void 0 : children.map((block) => RTEListBlockRenderer.render(block, renderContext));

package/dist/collection/components/vega-rich-text-editor/extensions/table/annotation-handler/table-annotation-handler-base.js

@@ -33,12 +33,29 @@ export class TableAnnotationHandlerBase extends AnnotationGeneratorStrategyAbstr
       const updatedBorderColor = borderColor === 'initial' ? '' : borderColor;
       return {
         style: borderStyle === 'initial' ? '' : borderStyle,
-        width: borderWidth === 'initial' ? '' : borderWidth,
+        width: this.normalizeBorderWidth(borderWidth),
         color: RTETableColorManager.getColorKey(updatedBorderColor) || updatedBorderColor,
       };
     }
     return null;
   }
+  /**
+   * Normalize a border width read from the DOM, dropping the `initial` value and the
+   * CSS keyword widths (`thin`/`medium`/`thick`). Those only appear as serialization
+   * artifacts of shorthand borders (e.g. `border: none` → `border-width: medium`) and
+   * are not valid numeric dimensions, so leaving them in would populate the properties
+   * "Weight" field with an invalid value and block the whole form from saving.
+   *
+   * @param {string} borderWidth - The raw border width read from the element style.
+   * @returns {string} The normalized border width (empty string when it is a keyword).
+   */
+  normalizeBorderWidth(borderWidth) {
+    if (borderWidth === 'initial' ||
+      TableAnnotationHandlerBase.BORDER_WIDTH_KEYWORDS.includes(borderWidth)) {
+      return '';
+    }
+    return borderWidth;
+  }
   /**
    * Extract width from element.
    *
@@ -76,3 +93,10 @@ export class TableAnnotationHandlerBase extends AnnotationGeneratorStrategyAbstr
     return null;
   }
 }
+/**
+ * CSS border-width keywords. These are produced as serialization artifacts when a
+ * shorthand border without an explicit width is round-tripped (e.g. `border: none`
+ * expands to `border-width: medium`). They are not valid numeric dimensions for the
+ * table/cell properties "Weight" field, so they are normalized away on import.
+ */
+TableAnnotationHandlerBase.BORDER_WIDTH_KEYWORDS = ['thin', 'medium', 'thick'];

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/li-to-rte-list-item-block-strategy.js

@@ -53,6 +53,8 @@ export class LiToRTEListItemBlockStrategy extends BlockToRTEBlockStrategyAbstrac
    */
   appendChildBlocks(currentBlock, childBlocks) {
     currentBlock.nestList = childBlocks.filter((block) => ['bullet-list', 'number-list'].includes(block.type));
+    // Maintain bidirectional parent link so that nested list blocks can traverse up to the list item.
+    currentBlock.nestList.forEach((block) => (block.parent = currentBlock));
   }
   /**
    * Should continue process to child elements.

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/abstract-delete-content-handler.js

@@ -61,11 +61,25 @@ export class AbstractDeleteContentHandler extends BaseHandler {
    * @returns {Nullable<RTENode>} The next node, or null when the given node is the last node of the content.
    */
   getNextNode(node) {
+    var _a;
     const block = node.parent;
     const nodeIndex = block.children.indexOf(node);
     if (nodeIndex >= 0 && nodeIndex < block.children.length - 1) {
       return block.children[nodeIndex + 1];
     }
+    // When the caret is at the end of a list item that owns nested lists, the next
+    // caret position is the first node of the first non-empty nested list, not the following sibling
+    // block. Descend into the item's own nestList before ascending to siblings so that
+    // a forward delete merges the first nested item up instead of skipping the whole
+    // nested list and merging the following sibling into the deepest nested item.
+    if (block.isListItemBlock() && ((_a = block.nestList) === null || _a === void 0 ? void 0 : _a.length)) {
+      for (const nestedList of block.nestList) {
+        const firstNestedNode = nestedList.getFirstNode();
+        if (firstNestedNode) {
+          return firstNestedNode;
+        }
+      }
+    }
     const nextBlock = this.getNextBlock(block);
     return nextBlock ? nextBlock.getFirstNode() : null;
   }
@@ -76,10 +90,25 @@ export class AbstractDeleteContentHandler extends BaseHandler {
    * @returns {Nullable<RTEBlock>} The next block, or null when the given block is the last block of the content.
    */
   getNextBlock(block) {
+    var _a, _b;
     const parent = block.parent;
     if (!parent || !parent.children) {
       return null;
     }
+    // Nested lists are owned through a list item's nestList collection rather than
+    // its children collection. Traverse the remaining nested-list branches before
+    // ascending to the owning item and its following siblings.
+    if (parent instanceof RTEBlock && parent.isListItemBlock()) {
+      const nestedListIndex = ((_a = parent.nestList) !== null && _a !== void 0 ? _a : []).indexOf(block);
+      if (nestedListIndex >= 0) {
+        for (const nestedList of ((_b = parent.nestList) !== null && _b !== void 0 ? _b : []).slice(nestedListIndex + 1)) {
+          if (nestedList.getFirstNode()) {
+            return nestedList;
+          }
+        }
+        return this.getNextBlock(parent);
+      }
+    }
     const siblings = parent.children;
     const blockIndex = siblings.indexOf(block);
     if (blockIndex >= 0 && siblings[blockIndex + 1]) {

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/base-handler.js

@@ -14,7 +14,7 @@ export class BaseHandler {
    * @param {VegaRTEContent} currentState - The current state of the VegaRTE content.
    * @param {SelectionController} selectionController - Manages the selection of items in the user interface.
    * @param {HTMLElement} richTextEditor - The current rich text editor component
-   * @param {InputEvent} [event] - It is used to pass an input event to the method for handling.
+   * @param {Event} [event] - It is used to pass an input event to the method for handling.
    */
   execute(currentState, selectionController, richTextEditor, event) {
     this.initCurrentStateAndSelection(currentState, selectionController);

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/keyboard-link-handler.js

@@ -0,0 +1,297 @@
+import { BaseHandler } from './base-handler';
+import { findParent } from '../../../../../../utils/ui';
+import stateEntityRenderingRegistry from '../../../controllers/state-entity-rendering-registry';
+import { RTETextNode } from '../../../../dto/nodes/text-node';
+import { RTEBlock } from '../../../../dto/blocks/block.abstract';
+/**
+ * Handles keyboard-based rich text link interactions (Escape close, Tab into the link popover, and
+ * the Command/Control+K open shortcut). Follows the input-event handler workflow so the keyboard
+ * link logic stays consistent with the other RTE handlers.
+ */
+export class KeyboardLinkHandler extends BaseHandler {
+  constructor() {
+    super(...arguments);
+    this.activeLinkEditor = null;
+    this.activeLinkWrapper = null;
+    this.linkPopoverHideHandler = null;
+    this.linkPopoverHideOwner = null;
+  }
+  /**
+   * Handles keyboard shortcuts for link popover open, close, and focus behavior.
+   *
+   * @param {KeyboardEvent} [event] - The keydown event fired from the editor.
+   */
+  handleEvent(event) {
+    if (!event) {
+      return;
+    }
+    if (event.key === 'Escape') {
+      if (this.activeLinkEditor) {
+        event.preventDefault();
+        event.stopPropagation();
+        void this.activeLinkEditor.hide();
+        return;
+      }
+      const linkWrapper = this.getFocusedLinkWrapper(event.target);
+      const linkEditor = this.getLinkEditorFromWrapper(linkWrapper);
+      if (linkEditor) {
+        event.preventDefault();
+        event.stopPropagation();
+        void linkEditor.hide();
+        return;
+      }
+    }
+    const linkWrapper = this.getFocusedLinkWrapper(event.target);
+    if (event.key === 'Tab' && !event.shiftKey && this.focusVisibleLinkPopoverAction(linkWrapper)) {
+      event.preventDefault();
+      event.stopPropagation();
+      const linkEditor = this.getLinkEditorFromWrapper(linkWrapper) || this.activeLinkEditor;
+      if (linkWrapper && linkEditor) {
+        this.registerLinkPopoverHideHandler(linkEditor, () => {
+          this.handleLinkPopoverHide(linkEditor, linkWrapper);
+        });
+      }
+      return;
+    }
+    const isOpenLinkShortcut = (event.metaKey || event.ctrlKey) && event.key.toLowerCase() === 'k';
+    if (!isOpenLinkShortcut || !linkWrapper) {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+    const linkEditor = linkWrapper.querySelector('vega-rich-text-link-editor');
+    if (!linkEditor) {
+      return;
+    }
+    this.activeLinkEditor = linkEditor;
+    this.activeLinkWrapper = linkWrapper;
+    this.registerLinkPopoverHideHandler(linkEditor, () => {
+      this.handleLinkPopoverHide(linkEditor, linkWrapper);
+    });
+    void linkEditor.show();
+  }
+  /**
+   * Releases any registered popover-hide listener when the owning controller is torn down.
+   */
+  dispose() {
+    this.unregisterLinkPopoverHideHandler();
+  }
+  /**
+   * Registers a one-time hide listener on the currently open link editor popover.
+   *
+   * @param {Nullable<HTMLElement>} linkEditor - Link editor that owns the popover.
+   * @param {EventListener} handler - Callback invoked when the popover hides.
+   */
+  registerLinkPopoverHideHandler(linkEditor, handler) {
+    const linkPopoverHideOwner = this.getLinkEditorPopover(linkEditor);
+    if (!linkPopoverHideOwner) {
+      return;
+    }
+    this.unregisterLinkPopoverHideHandler();
+    this.linkPopoverHideHandler = this.onLinkPopoverHide.bind(this, handler);
+    this.linkPopoverHideOwner = linkPopoverHideOwner;
+    linkPopoverHideOwner.addEventListener('vegaPopoverHide', this.linkPopoverHideHandler, {
+      once: true,
+    });
+  }
+  /**
+   * Executes the registered popover-hide callback and clears hide-listener state.
+   *
+   * @param {EventListener} handler - Registered callback for popover hide.
+   * @param {Event} event - Hide event payload.
+   */
+  onLinkPopoverHide(handler, event) {
+    handler(event);
+    this.linkPopoverHideHandler = null;
+    this.linkPopoverHideOwner = null;
+  }
+  /**
+   * Removes the currently registered popover hide listener if present.
+   */
+  unregisterLinkPopoverHideHandler() {
+    if (this.linkPopoverHideOwner && this.linkPopoverHideHandler) {
+      this.linkPopoverHideOwner.removeEventListener('vegaPopoverHide', this.linkPopoverHideHandler);
+    }
+    this.linkPopoverHideHandler = null;
+    this.linkPopoverHideOwner = null;
+  }
+  /**
+   * Resolves the closest focused link wrapper from event target or current selection.
+   *
+   * @param {EventTarget | null} target - Event target from the keydown event.
+   * @returns {Nullable<HTMLElement>} Link wrapper element if found.
+   */
+  getFocusedLinkWrapper(target) {
+    var _a;
+    const targetElement = target && target.nodeType === Node.ELEMENT_NODE ? target : null;
+    if (targetElement) {
+      const directWrapper = targetElement.classList.contains('link-editor-wrapper')
+        ? targetElement
+        : findParent(targetElement, '.link-editor-wrapper');
+      if (directWrapper) {
+        return directWrapper;
+      }
+    }
+    const anchorNode = ((_a = this.selectionController.getSelection()) === null || _a === void 0 ? void 0 : _a.anchorNode) || null;
+    const anchorElement = (anchorNode === null || anchorNode === void 0 ? void 0 : anchorNode.nodeType) === Node.ELEMENT_NODE
+      ? anchorNode
+      : (anchorNode === null || anchorNode === void 0 ? void 0 : anchorNode.parentElement) || null;
+    if (!anchorElement) {
+      return null;
+    }
+    return anchorElement.classList.contains('link-editor-wrapper')
+      ? anchorElement
+      : findParent(anchorElement, '.link-editor-wrapper');
+  }
+  /**
+   * Finds the link editor element inside a link wrapper.
+   *
+   * @typedef HTMLVegaRichTextLinkEditorElement - The type of the link editor element.
+   * @param {Nullable<HTMLElement>} linkWrapper - Wrapper that may contain the link editor component.
+   * @returns {Nullable<HTMLVegaRichTextLinkEditorElement>} Link editor if present.
+   */
+  getLinkEditorFromWrapper(linkWrapper) {
+    return ((linkWrapper === null || linkWrapper === void 0 ? void 0 : linkWrapper.querySelector('vega-rich-text-link-editor')) ||
+      null);
+  }
+  /**
+   * Gets the popover element rendered by a link editor.
+   *
+   * @param {Nullable<HTMLElement>} linkEditor - Link editor owning the popover.
+   * @returns {Nullable<LinkEditorPopoverElement>} Popover element when available.
+   */
+  getLinkEditorPopover(linkEditor) {
+    var _a;
+    return ((_a = linkEditor === null || linkEditor === void 0 ? void 0 : linkEditor.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('vega-popover')) || null;
+  }
+  /**
+   * Returns the popover content box associated with a link editor.
+   *
+   * @param {Nullable<HTMLElement>} linkEditor - Link editor owning the popover.
+   * @returns {Nullable<HTMLElement>} Popover content box element.
+   */
+  getLinkEditorPopoverContentBox(linkEditor) {
+    var _a, _b;
+    const popover = this.getLinkEditorPopover(linkEditor);
+    return ((_b = (_a = popover === null || popover === void 0 ? void 0 : popover.appenderRenderer) === null || _a === void 0 ? void 0 : _a.getPopoverContentBox) === null || _b === void 0 ? void 0 : _b.call(_a)) || null;
+  }
+  /**
+   * Clears active link editor state and restores focus to the provided wrapper.
+   *
+   * @param {Nullable<HTMLElement>} linkEditor - Link editor that has just hidden.
+   * @param {Nullable<HTMLElement>} [focusTarget] - Optional element to receive focus.
+   */
+  handleLinkPopoverHide(linkEditor, focusTarget) {
+    const resolvedFocusTarget = focusTarget || this.activeLinkWrapper;
+    if (!linkEditor || this.activeLinkEditor === linkEditor) {
+      this.activeLinkEditor = null;
+      this.activeLinkWrapper = null;
+    }
+    if (resolvedFocusTarget) {
+      this.placeLinkCaretAtEnd(resolvedFocusTarget);
+    }
+  }
+  /**
+   * Focuses the first visible link action in the current link popover.
+   *
+   * @param {Nullable<HTMLElement>} [linkWrapper] - Optional focused link wrapper context.
+   * @returns {boolean} True when focus moved to an action button.
+   */
+  focusVisibleLinkPopoverAction(linkWrapper) {
+    var _a;
+    const ownerDocument = ((_a = this.richTextEditorRef) === null || _a === void 0 ? void 0 : _a.ownerDocument) || null;
+    if (!ownerDocument) {
+      return false;
+    }
+    const linkEditor = this.getLinkEditorFromWrapper(linkWrapper || null) || this.activeLinkEditor;
+    const popoverContentBox = this.getPreferredLinkActionPopover(ownerDocument, linkEditor);
+    if (!popoverContentBox) {
+      return false;
+    }
+    const focusableActionButton = this.getFirstFocusableLinkActionButton(popoverContentBox);
+    if (!focusableActionButton) {
+      return false;
+    }
+    focusableActionButton.focus();
+    return true;
+  }
+  /**
+   * Prefers a scoped link-action popover and falls back to globally visible ones.
+   *
+   * @param {Document} ownerDocument - Document owning editor popovers.
+   * @param {Nullable<HTMLElement>} [linkEditor] - Optional scoped link editor.
+   * @returns {Nullable<HTMLElement>} Best popover content box to target.
+   */
+  getPreferredLinkActionPopover(ownerDocument, linkEditor) {
+    const scopedPopoverContentBox = this.getLinkEditorPopoverContentBox(linkEditor || null);
+    if (scopedPopoverContentBox &&
+      !scopedPopoverContentBox.classList.contains('vega-force-hidden') &&
+      this.isLinkActionPopover(scopedPopoverContentBox)) {
+      return scopedPopoverContentBox;
+    }
+    const popoverContentBoxes = Array.from(ownerDocument.querySelectorAll('vega-popover-content-box'));
+    const linkActionPopovers = popoverContentBoxes.filter((box) => this.isLinkActionPopover(box));
+    const visibleLinkActionPopovers = linkActionPopovers.filter((box) => !box.classList.contains('vega-force-hidden'));
+    return visibleLinkActionPopovers[visibleLinkActionPopovers.length - 1] || null;
+  }
+  /**
+   * Checks whether a popover represents the link action menu.
+   *
+   * @param {HTMLElement} popoverContentBox - Popover content box to inspect.
+   * @returns {boolean} True when both edit and unlink actions exist.
+   */
+  isLinkActionPopover(popoverContentBox) {
+    const items = Array.from(popoverContentBox.querySelectorAll('vega-button-group-item'));
+    const hasEditAction = items.some((item) => item.itemKey === 'edit');
+    const hasUnlinkAction = items.some((item) => item.itemKey === 'unlink');
+    return hasEditAction && hasUnlinkAction;
+  }
+  /**
+   * Gets the preferred focusable element from the first link action item.
+   *
+   * @param {HTMLElement} popoverContentBox - Link action popover content box.
+   * @returns {Nullable<HTMLElement>} Focusable anchor or button element.
+   */
+  getFirstFocusableLinkActionButton(popoverContentBox) {
+    var _a, _b, _c, _d;
+    const allItems = Array.from(popoverContentBox.querySelectorAll('vega-button-group-item'));
+    const firstActionItem = allItems.find((item) => item.itemKey === 'edit') ||
+      allItems[0] ||
+      null;
+    if (!firstActionItem) {
+      return null;
+    }
+    const firstActionLinkWrapper = ((_a = firstActionItem.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('vega-button-link')) || null;
+    const firstActionButtonWrapper = ((_b = firstActionItem.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('vega-button')) || null;
+    return (((_c = firstActionLinkWrapper === null || firstActionLinkWrapper === void 0 ? void 0 : firstActionLinkWrapper.shadowRoot) === null || _c === void 0 ? void 0 : _c.querySelector('a')) ||
+      ((_d = firstActionButtonWrapper === null || firstActionButtonWrapper === void 0 ? void 0 : firstActionButtonWrapper.shadowRoot) === null || _d === void 0 ? void 0 : _d.querySelector('button')) ||
+      null);
+  }
+  /**
+   * Places the editor caret at the end of the link when the popover closes.
+   *
+   * @param {Nullable<HTMLElement>} linkWrapper - The link wrapper element containing link text nodes.
+   */
+  placeLinkCaretAtEnd(linkWrapper) {
+    var _a;
+    if (!linkWrapper) {
+      return;
+    }
+    const allTextSpans = Array.from(linkWrapper.querySelectorAll('span'));
+    if (allTextSpans.length === 0) {
+      return;
+    }
+    const lastTextSpan = allTextSpans[allTextSpans.length - 1];
+    const lastNodeEntity = stateEntityRenderingRegistry.getEntityByDOM(lastTextSpan);
+    if (!lastNodeEntity || lastNodeEntity instanceof RTEBlock) {
+      return;
+    }
+    if (!(lastNodeEntity instanceof RTETextNode)) {
+      return;
+    }
+    const lastNode = lastNodeEntity;
+    const endOffset = ((_a = lastNode.text) === null || _a === void 0 ? void 0 : _a.length) || 0;
+    // Place caret at the end of the link when popover closes
+    this.selectionController.enqueueSelectionRangeFutureState(lastNode, endOffset, lastNode, endOffset, true);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/user-input-controller.js

@@ -12,6 +12,7 @@ import { ForwardDeleteContentHandler } from './helper/input-event-handler/forwar
 import { BackwardDeleteContentHandler } from './helper/input-event-handler/backward-delete-content-handler';
 import { VegaRTEContent } from '../../dto/content-state';
 import { InsertPasteHandler } from './helper/input-event-handler/insert-paste-handler';
+import { KeyboardLinkHandler } from './helper/input-event-handler/keyboard-link-handler';
 import { generateUUID } from '../../../../utils/misc';
 import { RTECodeBlock } from '../../dto/blocks/code-block';
 /** Used to monitoring the user input actions by event listener */
@@ -24,6 +25,15 @@ export class UserInputController extends VegaSlimmer {
     this.forwardDeleteContentHandler = new ForwardDeleteContentHandler();
     this.backwardDeleteContentHandler = new BackwardDeleteContentHandler();
     this.insertPasteHandler = new InsertPasteHandler();
+    this.keyboardLinkHandler = new KeyboardLinkHandler();
+    /**
+     * Dispatches editor keydown events to the keyboard link handler using the shared handler workflow.
+     *
+     * @param {KeyboardEvent} event - The keydown event fired from the editor.
+     */
+    this.handleKeyboardAction = (event) => {
+      this.keyboardLinkHandler.execute(this.value, this.selectionController, this.host, event);
+    };
     /**
      * When a user performs an input action within the editable element, this function is triggered.
      *
@@ -78,6 +88,7 @@ export class UserInputController extends VegaSlimmer {
     const editableElement = this.getEditableElementRef();
     if (editableElement) {
       editableElement.addEventListener('beforeinput', this.handleUserInputAction);
+      editableElement.addEventListener('keydown', this.handleKeyboardAction);
       editableElement.addEventListener('drop', this.preventDropEvent);
     }
   }
@@ -88,8 +99,10 @@ export class UserInputController extends VegaSlimmer {
     const editableElement = this.getEditableElementRef();
     if (editableElement) {
       editableElement.removeEventListener('beforeinput', this.handleUserInputAction);
+      editableElement.removeEventListener('keydown', this.handleKeyboardAction);
       editableElement.removeEventListener('drop', this.preventDropEvent);
     }
+    this.keyboardLinkHandler.dispose();
   }
   /**
    * The function `getEditableElementRef` returns a reference to the editable HTMLDivElement within a rich text editor.