@globalpayments/vega 2.101.0 → 2.102.0

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

@@ -73,7 +73,8 @@ class RTELinkWrapperRenderer {
    * @param {RTERenderContext} context - Context containing render options.
    * @returns {VegaRTERenderResult[]} - Array of rendered HTML elements.
    */
-  render(nodes, linkGroupAnnotation, { editable, host }) {
+  render(nodes, linkGroupAnnotation, renderContext) {
+    const { editable, host } = renderContext;
     const blockNodes = this.groupNodesByLink(nodes);
     return blockNodes
       .flatMap((item) => {
@@ -94,11 +95,11 @@ class RTELinkWrapperRenderer {
         linkAnnotation = item[0].getAnnotationByType(NodeAnnotationTypeEnum.LINK);
         return editable
           ? this.renderLinkEditorWrapper(item, linkAnnotation, linkGroupAnnotation)
-          : this.renderLink(item, linkAnnotation, linkGroupAnnotation);
+          : this.renderLink(item, linkAnnotation, linkGroupAnnotation, true);
       }
       const nodeRenderer = RTEDTORendererManager.getRTERenderer(item.type);
       if (nodeRenderer) {
-        return nodeRenderer.render(item, { editable }, h);
+        return nodeRenderer.render(item, renderContext, h);
       }
     })
       .filter(isNonNullable);
@@ -151,8 +152,27 @@ class RTELinkWrapperRenderer {
           }
         } })));
   }
-  renderLink(linkNodes, linkAnnotation, linkGroupAnnotation) {
-    return (h("a", Object.assign({}, linkGroupAnnotation.toJsx(linkAnnotation)), linkNodes.map((node) => RTETextNodeRenderer.render(node))));
+  renderLink(linkNodes, linkAnnotation, linkGroupAnnotation, handleBookmarkNavigation = false) {
+    const { href } = linkAnnotation.link;
+    const bookmarkClickHandler = handleBookmarkNavigation && (href === null || href === void 0 ? void 0 : href.startsWith('#'))
+      ? (event) => this.handleBookmarkNavigation(event, href)
+      : null;
+    const linkAttributes = Object.assign(Object.assign({}, linkGroupAnnotation.toJsx(linkAnnotation)), (bookmarkClickHandler ? { onClick: bookmarkClickHandler } : {}));
+    return (h("a", Object.assign({}, linkAttributes), linkNodes.map((node) => RTETextNodeRenderer.render(node))));
+  }
+  handleBookmarkNavigation(event, href) {
+    const bookmarkName = href.slice(1);
+    const link = event.currentTarget;
+    const rootNode = link === null || link === void 0 ? void 0 : link.getRootNode();
+    if (!bookmarkName || !rootNode || !('querySelectorAll' in rootNode)) {
+      return;
+    }
+    const bookmarkTarget = Array.from(rootNode.querySelectorAll('a.rte-bookmark[id]')).find((anchor) => anchor.id === bookmarkName);
+    if (!bookmarkTarget) {
+      return;
+    }
+    event.preventDefault();
+    bookmarkTarget.scrollIntoView({ block: 'center', inline: 'nearest' });
   }
   normalizeLinkNodesByDefaultProtocol(linkNodes, host) {
     if (!host || linkNodes.length === 0) {

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

@@ -40,4 +40,5 @@ class RTEListBlockRenderer extends RTEBlockRenderer {
     return depth;
   }
 }
+RTEListBlockRenderer.typeName = 'RTEListBlockRenderer';
 export default new RTEListBlockRenderer();

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

@@ -28,4 +28,5 @@ class RTEListItemBlockRenderer extends RTEBlockTextNodesRenderer {
     return children === null || children === void 0 ? void 0 : children.map((block) => RTEListBlockRenderer.render(block, renderContext));
   }
 }
+RTEListItemBlockRenderer.typeName = 'RTEListItemBlockRenderer';
 export default new RTEListItemBlockRenderer();

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

@@ -22,4 +22,5 @@ class RTETextBlockRenderer extends RTEBlockTextNodesRenderer {
     return children[0].getInlineHtmlTagAtDepth(0);
   }
 }
+RTETextBlockRenderer.typeName = 'RTETextBlockRenderer';
 export default new RTETextBlockRenderer();

package/dist/collection/components/vega-rich-text-editor/dto/renderers/nodes/code-block-node-renderer.js

@@ -75,4 +75,5 @@ class RTECodeBlockNodeRenderer extends RTENodeRenderer {
     }
   }
 }
+RTECodeBlockNodeRenderer.typeName = 'RTECodeBlockNodeRenderer';
 export default new RTECodeBlockNodeRenderer();

package/dist/collection/components/vega-rich-text-editor/dto/renderers/nodes/image-node-renderer.js

@@ -115,4 +115,5 @@ class RTEImageNodeRenderer extends RTENodeRenderer {
     return `${RTEDecoratorNode.DECORATOR_CONTAINER_CLASS} ${this.getClasses(node)}`;
   }
 }
+RTEImageNodeRenderer.typeName = 'RTEImageNodeRenderer';
 export default new RTEImageNodeRenderer();

package/dist/collection/components/vega-rich-text-editor/dto/renderers/nodes/node-renderer.abstract.js

@@ -7,3 +7,4 @@ export class RTENodeRenderer extends VegaRTEBaseRenderer {
     }
   }
 }
+RTENodeRenderer.typeName = 'RTENodeRenderer';

package/dist/collection/components/vega-rich-text-editor/dto/renderers/nodes/text-node-renderer.js

@@ -48,4 +48,5 @@ class RTETextNodeRenderer extends RTENodeRenderer {
     return h(HtmlTag, Object.assign({}, attrs), node.text || ZERO_WIDTH_SPACE);
   }
 }
+RTETextNodeRenderer.typeName = 'RTETextNodeRenderer';
 export default new RTETextNodeRenderer();

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

@@ -64,11 +64,11 @@ RTEDTOClassManager.registerRTEDTOClass('html-block', RTEHtmlBlock);
 RTEDTOClassManager.registerRTEDTOClass('text', RTETextNode);
 RTEDTOClassManager.registerRTEDTOClass('image', RTEImageNode);
 // Register basic strategies for default block DTOs
-RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTETextBlock.name);
-RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEListBlock.name);
-RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEListItemBlock.name);
-RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEImageBlock.name);
-RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEHtmlBlock.name);
+RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTETextBlock.typeName);
+RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEListBlock.typeName);
+RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEListItemBlock.typeName);
+RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEImageBlock.typeName);
+RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEHtmlBlock.typeName);
 // Register element to DTO strategies for default node DTOs, The order of registration matters, the later registered strategy has higher priority.
 ElementToDTOClassStrategyManager.registerElementToBlockStrategy(new ContinueInlineToRTETextBlockStrategy());
 ElementToDTOClassStrategyManager.registerElementToBlockStrategy(new SpanImageToRTEImageBlockStrategy());
@@ -86,32 +86,32 @@ ElementToDTOClassStrategyManager.registerElementToBlockStrategy(new VegaCodeBloc
 ElementToDTOClassStrategyManager.registerElementToNodeStrategy(new InlineElementToTextNodeStrategy());
 ElementToDTOClassStrategyManager.registerElementToNodeStrategy(new PlainTextToTextNodeStrategy());
 // Register filter styles strategies (remove redundant default styles during HTML → DTO conversion)
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new AlignmentFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTEListBlock.dtoName, new AlignmentFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new AlignmentFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTETextNode.dtoName, new TextFormatFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new ParagraphFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new HeadingFilterStylesStrategy(1));
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new HeadingFilterStylesStrategy(2));
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new HeadingFilterStylesStrategy(3));
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new HeadingFilterStylesStrategy(4));
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new HeadingFilterStylesStrategy(5));
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new HeadingFilterStylesStrategy(6));
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new TitleFilterStylesStrategy('title'));
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new TitleFilterStylesStrategy('subtitle'));
-RTEFilterStylesStrategyRegistry.register(RTETextNode.dtoName, new TitleHeadingNodeFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTETextNode.dtoName, new CodeFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTETextNode.dtoName, new LinkFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTEImageNode.dtoName, new ImageFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTECodeBlock.dtoName, new CodeBlockFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTECodeBlockNode.dtoName, new CodeBlockNodeFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTEListBlock.dtoName, new ListBlockFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListItemBlockFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListHeadingItemBlockFilterStylesStrategy(1));
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListHeadingItemBlockFilterStylesStrategy(2));
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListHeadingItemBlockFilterStylesStrategy(3));
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListHeadingItemBlockFilterStylesStrategy(4));
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListHeadingItemBlockFilterStylesStrategy(5));
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListHeadingItemBlockFilterStylesStrategy(6));
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListTitleItemBlockFilterStylesStrategy('title'));
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListTitleItemBlockFilterStylesStrategy('subtitle'));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new AlignmentFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEListBlock.typeName, new AlignmentFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new AlignmentFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTETextNode.typeName, new TextFormatFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new ParagraphFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new HeadingFilterStylesStrategy(1));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new HeadingFilterStylesStrategy(2));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new HeadingFilterStylesStrategy(3));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new HeadingFilterStylesStrategy(4));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new HeadingFilterStylesStrategy(5));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new HeadingFilterStylesStrategy(6));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new TitleFilterStylesStrategy('title'));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new TitleFilterStylesStrategy('subtitle'));
+RTEFilterStylesStrategyRegistry.register(RTETextNode.typeName, new TitleHeadingNodeFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTETextNode.typeName, new CodeFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTETextNode.typeName, new LinkFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEImageNode.typeName, new ImageFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTECodeBlock.typeName, new CodeBlockFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTECodeBlockNode.typeName, new CodeBlockNodeFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEListBlock.typeName, new ListBlockFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListItemBlockFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListHeadingItemBlockFilterStylesStrategy(1));
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListHeadingItemBlockFilterStylesStrategy(2));
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListHeadingItemBlockFilterStylesStrategy(3));
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListHeadingItemBlockFilterStylesStrategy(4));
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListHeadingItemBlockFilterStylesStrategy(5));
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListHeadingItemBlockFilterStylesStrategy(6));
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListTitleItemBlockFilterStylesStrategy('title'));
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListTitleItemBlockFilterStylesStrategy('subtitle'));

package/dist/collection/components/vega-rich-text-editor/extensions/base-extension-renderer.js

@@ -112,4 +112,5 @@ export class VegaRTEExtensionRenderer extends VegaRTEBaseRenderer {
     }
   }
 }
+VegaRTEExtensionRenderer.typeName = 'VegaRTEExtensionRenderer';
 VegaRTEExtensionRenderer.REGISTER_REF_FLAG = '__registeredRef__';

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/blockquote-extension.js

@@ -21,27 +21,27 @@ export class VegaRTEBlockquoteExtension extends VegaRTEExtension {
   constructor() {
     super();
     this.toolbarButtonRenderer = new RTEBlockquoteToolbarButtonRenderer();
-    this.registerBlockBasicStrategies(RTEBlockquoteBlock.name);
+    this.registerBlockBasicStrategies(RTEBlockquoteBlock.typeName);
     this.registerNode('blockquote', RTEBlockquoteBlock);
     this.registerRenderer('blockquote', RTEBlockquoteBlockRenderer);
     this.registerToolbarButtonRenderer(VegaRTEBlockquoteExtension.TOOLBAR_BUTTON_KEY, this.toolbarButtonRenderer);
     this.registerElementToBlockDTOClassStrategy(new BlockquoteToBlockquoteBlockStrategy());
     // Register filter styles strategy for source edit round-trip.
-    VegaRTEExtension.registerFilterStylesStrategy(RTEBlockquoteBlock.dtoName, new BlockquoteFilterStylesStrategy());
+    VegaRTEExtension.registerFilterStylesStrategy(RTEBlockquoteBlock.typeName, new BlockquoteFilterStylesStrategy());
   }
 }
 (() => {
   const wrapStrategy = new BlockTransformToBlockquoteStrategy();
   // Root container — wrap top-level blocks.
-  VegaRTEExtension.registerActionHandleStrategy(VegaRTEContent.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(VegaRTEContent.typeName, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
   // Table cells (body + header) — wrap is scoped to the closest cell.
   // Other container blocks (code, list item, function) are intentionally
   // not registered, so the toolbar stays disabled inside them.
-  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTEBlockquoteBlock.name, REMOVE_BLOCKQUOTE, new RemoveBlockquoteStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.typeName, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.typeName, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTEBlockquoteBlock.typeName, REMOVE_BLOCKQUOTE, new RemoveBlockquoteStrategy());
   // Enables exiting the blockquote via the keyboard: pressing Enter on an empty
   // trailing paragraph breaks out to a new paragraph after the blockquote.
-  VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.name, ModifyContentActionType.INSERT_NEW_PARAGRAPH, new BlockquoteExitOnEnterInterceptor());
+  VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.typeName, ModifyContentActionType.INSERT_NEW_PARAGRAPH, new BlockquoteExitOnEnterInterceptor());
 })();
 VegaRTEBlockquoteExtension.TOOLBAR_BUTTON_KEY = 'blockquote';

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/dto/rte-blockquote-block.js

@@ -6,7 +6,6 @@ import { BlockquoteAnnotation } from './blockquote-annotation';
 export class RTEBlockquoteBlock extends RTEBlock {
   constructor(id, options) {
     super(id);
-    this.dtoName = RTEBlockquoteBlock.dtoName;
     this.type = 'blockquote';
     this.children = [];
     const { autoMatchFormat = true } = options !== null && options !== void 0 ? options : {};
@@ -67,4 +66,4 @@ export class RTEBlockquoteBlock extends RTEBlock {
     return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: 'blockquote', children: this.children.map((child) => child.toJSON()) });
   }
 }
-RTEBlockquoteBlock.dtoName = 'RTEBlockquoteBlock';
+RTEBlockquoteBlock.typeName = 'RTEBlockquoteBlock';

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

@@ -24,7 +24,7 @@ export class BlockquoteFilterStylesStrategy extends RTEFilterStylesStrategy {
    * @inheritDoc
    */
   canFilter(blockOrNodeInstance) {
-    return BlockquoteFilterStylesStrategy.isBlockquoteBlock(blockOrNodeInstance.dtoName);
+    return BlockquoteFilterStylesStrategy.isBlockquoteBlock(blockOrNodeInstance.typeName);
   }
   /**
    * @inheritDoc

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/renderers/blockquote-block-renderer.js

@@ -18,4 +18,5 @@ export class RTEBlockquoteBlockRenderer extends VegaRTEExtensionRenderer {
     return BlockquoteAnnotation.getDefaultCssText();
   }
 }
+RTEBlockquoteBlockRenderer.typeName = 'RTEBlockquoteBlockRenderer';
 export default new RTEBlockquoteBlockRenderer();

package/dist/collection/components/vega-rich-text-editor/extensions/bookmark/action-handler-interceptors/delete-bookmark-before-text-interceptor.js

@@ -0,0 +1,40 @@
+import { ActionHandlerInterceptor, } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
+import { UpdateTextAction } from '../../../dto/actions/update-text-action';
+import { RTETextNode } from '../../../dto/nodes/text-node';
+import { RTEBookmarkNode } from '../bookmark-node';
+/**
+ * Removes a bookmark when Backspace is pressed at the start of its following text node.
+ */
+export class DeleteBookmarkBeforeTextInterceptor extends ActionHandlerInterceptor {
+  /**
+   * @inheritDoc
+   */
+  canIntercept(action, target) {
+    const { startContainerNode, startOffset } = action;
+    if (!(startContainerNode instanceof RTETextNode)) {
+      return false;
+    }
+    const nodeIndex = target.children.indexOf(startContainerNode);
+    return (startContainerNode.parent === target &&
+      nodeIndex > 0 &&
+      target.children[nodeIndex - 1] instanceof RTEBookmarkNode &&
+      (startOffset === 0 ||
+        (startContainerNode.text.length === 1 && startOffset === startContainerNode.text.length)));
+  }
+  /**
+   * @inheritDoc
+   */
+  intercept(_execution, action, target) {
+    const startContainerNode = action.startContainerNode;
+    if (startContainerNode.text.length === 1 && action.startOffset === 1) {
+      startContainerNode.apply(new UpdateTextAction(''));
+      action.previousNode = startContainerNode;
+      return;
+    }
+    const nodeIndex = target.children.indexOf(startContainerNode);
+    const bookmarkNode = target.children[nodeIndex - 1];
+    target.apply(new RemoveChildrenAction(bookmarkNode));
+    action.nextNode = startContainerNode;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/bookmark/action-handler-strategies/insert-bookmark-node-strategy.js

@@ -0,0 +1,20 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { InsertNodeToNearestRootAction } from '../../../dto/actions/insert-node-to-nearest-root-action';
+import { RTEBookmarkNode } from '../bookmark-node';
+/**
+ * Strategy to handle the insertion of a bookmark node into the nearest root block.
+ */
+export class InsertBookmarkNodeStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, block) {
+    const { rteRange, name } = action;
+    if (rteRange && rteRange.startNode) {
+      const bookmarkNode = new RTEBookmarkNode(generateUUID(), name, block);
+      block.apply(new InsertNodeToNearestRootAction(rteRange, bookmarkNode));
+      action.actionHandleResult = true;
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/bookmark/action-handler-strategies/update-bookmark-name-strategy.js

@@ -0,0 +1,12 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+/**
+ * Strategy to rename an existing bookmark node.
+ */
+export class UpdateBookmarkNameStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, node) {
+    node.name = action.name;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/bookmark/actions/insert-bookmark-node-action.js

@@ -0,0 +1,17 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+export const INSERT_BOOKMARK_NODE = 'INSERT_BOOKMARK_NODE';
+/**
+ * Action to insert a bookmark node at a specified range in the Rich Text Editor.
+ *
+ * @example block.apply(new InsertBookmarkNodeAction(rteRange, 'Rights'));
+ */
+export class InsertBookmarkNodeAction extends ModifyContentAction {
+  constructor(rteRange, name) {
+    super();
+    this.type = INSERT_BOOKMARK_NODE;
+    this.rteRange = null;
+    this.actionHandleResult = false;
+    this.rteRange = rteRange;
+    this.name = name;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/bookmark/actions/update-bookmark-name-action.js

@@ -0,0 +1,14 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+export const UPDATE_BOOKMARK_NAME = 'UPDATE_BOOKMARK_NAME';
+/**
+ * Action to rename an existing bookmark node.
+ *
+ * @example bookmarkNode.apply(new UpdateBookmarkNameAction('Rights'));
+ */
+export class UpdateBookmarkNameAction extends ModifyContentAction {
+  constructor(name) {
+    super();
+    this.type = UPDATE_BOOKMARK_NAME;
+    this.name = name;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/bookmark/anchor-to-bookmark-node-strategy.js

@@ -0,0 +1,79 @@
+import { generateUUID } from '../../../../utils/misc';
+import { ElementToDTOStrategy } from '../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+/**
+ * Strategy to convert anchor elements into bookmark nodes.
+ *
+ * Supported inputs:
+ * - `<a id="Rights"></a>` — the CKEditor 5 bookmark contract.
+ * - `<a name="Rights"></a>` — the legacy CKEditor 4 anchor format.
+ *
+ * Only empty named anchors become bookmarks. Anchors with content, or anchors carrying an `href`,
+ * are left untouched so existing link/text handling is preserved.
+ */
+export class AnchorToBookmarkNodeStrategy extends ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray, currentIndex) {
+    const element = elementsArray[currentIndex];
+    return this.isBookmarkAnchor(element) ? 1 : 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray) {
+    const element = elementsArray[0];
+    const name = this.resolveBookmarkName(element);
+    if (!name) {
+      return null;
+    }
+    return {
+      id: generateUUID(),
+      type: 'bookmark',
+      text: '',
+      name,
+    };
+  }
+  /**
+   * @inheritDoc
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  appendChildBlocks() { }
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren() {
+    return false;
+  }
+  /**
+   * Checks whether the element is an anchor that represents a bookmark target.
+   *
+   * @param {HTMLElement} element - The element to check.
+   * @returns {boolean} True when the element is a bookmark anchor.
+   */
+  isBookmarkAnchor(element) {
+    return (!!element &&
+      element.nodeName === 'A' &&
+      !element.hasAttribute('href') &&
+      this.isEmptyAnchor(element) &&
+      !!this.resolveBookmarkName(element));
+  }
+  /**
+   * Reads the bookmark name from the anchor, preferring `id` over the legacy `name` attribute.
+   *
+   * @param {HTMLElement} element - The anchor element.
+   * @returns {string} The bookmark name, or an empty string when absent.
+   */
+  resolveBookmarkName(element) {
+    return (element.getAttribute('id') || element.getAttribute('name') || '').trim();
+  }
+  /**
+   * Checks whether the anchor has no meaningful content.
+   *
+   * @param {HTMLElement} element - The anchor element.
+   * @returns {boolean} True when the anchor is effectively empty.
+   */
+  isEmptyAnchor(element) {
+    return (element.textContent || '').trim().length === 0 && element.children.length === 0;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/bookmark/assets/bookmark.js

@@ -0,0 +1,5 @@
+export const BOOKMARK_ICON_VIEW_BOX = '0 0 384 512';
+export const BOOKMARK_ICON_PATH = 'M0 48V487.7C0 501.1 10.9 512 24.3 512c5 0 9.9-1.5 14-4.4L192 400 345.7 507.6c4.1 2.9 9 4.4 14 4.4c13.4 0 24.3-10.9 24.3-24.3V48c0-26.5-21.5-48-48-48H48C21.5 0 0 21.5 0 48z';
+export default {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${BOOKMARK_ICON_VIEW_BOX}"><path fill="currentColor" d="${BOOKMARK_ICON_PATH}"/></svg>`,
+};

package/dist/collection/components/vega-rich-text-editor/extensions/bookmark/bookmark-extension.js

@@ -0,0 +1,52 @@
+import { RTEListItemBlock } from '../../dto/blocks/list-item-block';
+import { RTETextBlock } from '../../dto/blocks/text-block';
+import { ModifyContentActionType } from '../../dto/actions/modify-content-action.abstract';
+import { VegaRTEExtension } from '../extension.abstract';
+import { DeleteBookmarkBeforeTextInterceptor } from './action-handler-interceptors/delete-bookmark-before-text-interceptor';
+import { UpdateBookmarkNameStrategy } from './action-handler-strategies/update-bookmark-name-strategy';
+import { InsertBookmarkNodeStrategy } from './action-handler-strategies/insert-bookmark-node-strategy';
+import { INSERT_BOOKMARK_NODE } from './actions/insert-bookmark-node-action';
+import { UPDATE_BOOKMARK_NAME } from './actions/update-bookmark-name-action';
+import { AnchorToBookmarkNodeStrategy } from './anchor-to-bookmark-node-strategy';
+import { RTEBookmarkNode } from './bookmark-node';
+import { RTEBookmarkNodeRenderer } from './renderers/bookmark-node-renderer';
+import { RTEBookmarkToolbarButtonRenderer } from './renderers/bookmark-toolbar-button-renderer';
+// Module scoped so repeated extension instances reuse the same strategy reference instead of registering duplicates.
+const anchorToBookmarkNodeStrategy = new AnchorToBookmarkNodeStrategy();
+/**
+ * Extension that adds bookmark (named anchor) support to the Vega Rich Text Editor.
+ *
+ * A bookmark is a zero-width, named marker that serializes to `<a id="name"></a>` so it can
+ * be used as a local link target.
+ */
+export class VegaRTEBookmarkExtension extends VegaRTEExtension {
+  constructor() {
+    super();
+    this.bookmarkRenderer = new RTEBookmarkNodeRenderer();
+    this.registerNode('bookmark', RTEBookmarkNode);
+    this.registerRenderer('bookmark', this.bookmarkRenderer);
+    this.registerElementToNodeDTOClassStrategy(anchorToBookmarkNodeStrategy);
+  }
+  /** @inheritDoc */
+  prepareBeforeLoad(host) {
+    this.registerToolbarButtonRenderer(VegaRTEBookmarkExtension.TOOLBAR_BUTTON_KEY, new RTEBookmarkToolbarButtonRenderer(), host);
+  }
+  /** Removes the per-host bookmark selection listener when the editor is destroyed. */
+  destroyExtension() {
+    var _a;
+    const host = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.host;
+    if (host) {
+      this.bookmarkRenderer.teardownRangeHighlight(host);
+    }
+  }
+}
+(() => {
+  const insertBookmarkNodeStrategy = new InsertBookmarkNodeStrategy();
+  VegaRTEExtension.registerActionHandleStrategy(RTETextBlock.typeName, INSERT_BOOKMARK_NODE, insertBookmarkNodeStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTEListItemBlock.typeName, INSERT_BOOKMARK_NODE, insertBookmarkNodeStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTEBookmarkNode.typeName, UPDATE_BOOKMARK_NAME, new UpdateBookmarkNameStrategy());
+  const deleteBookmarkBeforeTextInterceptor = new DeleteBookmarkBeforeTextInterceptor();
+  VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.typeName, ModifyContentActionType.DELETE_BLOCK_CONTENT, deleteBookmarkBeforeTextInterceptor);
+  VegaRTEExtension.registerActionHandlerInterceptor(RTEListItemBlock.typeName, ModifyContentActionType.DELETE_BLOCK_CONTENT, deleteBookmarkBeforeTextInterceptor);
+})();
+VegaRTEBookmarkExtension.TOOLBAR_BUTTON_KEY = 'bookmark';

package/dist/collection/components/vega-rich-text-editor/extensions/bookmark/bookmark-node.js

@@ -0,0 +1,91 @@
+import { BoldAnnotationAction } from '../../dto/actions/bold-annotation-action';
+import { DeleteNodeAnnotationAction } from '../../dto/actions/delete-node-annotation-action';
+import { NodeAnnotationTypeEnum } from '../../dto/annotations/node-annotation.abstract';
+import { RTETextNode } from '../../dto/nodes/text-node';
+import { escapeHtmlAttribute } from '../../helpers/utils';
+/**
+ * Bookmark node for the Vega Rich Text Editor.
+ *
+ * A bookmark is a named, zero-width marker that can be used as a local link target.
+ * It carries no text content and is never directly editable by the user.
+ */
+export class RTEBookmarkNode extends RTETextNode {
+  constructor(id, name, parentBlock, annotations) {
+    super(id, '', parentBlock, annotations);
+    this.dtoName = RTEBookmarkNode.dtoName;
+    this.type = 'bookmark';
+    this.name = name;
+  }
+  /**
+   * @inheritDoc
+   */
+  static from(value, parent) {
+    const node = new RTEBookmarkNode(value.id, value.name, parent);
+    if (value.annotations) {
+      node.annotationMap = this.generateTextAnnotationMap(value.annotations);
+    }
+    return node;
+  }
+  /**
+   * Converts the bookmark node to a JSON representation.
+   *
+   * @returns {VegaRTEBookmarkNode} - The JSON representation of the bookmark node.
+   */
+  toJSON() {
+    const serializedNode = super.toJSON();
+    const annotations = serializedNode.annotations;
+    return Object.assign(Object.assign({ id: this.id }, (annotations ? { annotations } : {})), { type: this.type, text: '', name: this.name });
+  }
+  /**
+   * Bookmarks are markers only, so their content can never be edited directly.
+   *
+   * @returns {boolean} - Always returns false for bookmark nodes.
+   */
+  isContentEditable() {
+    return false;
+  }
+  /**
+   * Clones the bookmark node.
+   *
+   * @param {RTETextBlock} parent - The parent block for the cloned node.
+   * @returns {RTEBookmarkNode} - The cloned bookmark node.
+   */
+  clone(parent) {
+    return new RTEBookmarkNode(this.id, this.name, parent, super.cloneAnnotations());
+  }
+  /**
+   * Checks if a node is empty
+   *
+   * @returns {boolean}  It returns `true` if the node is empty
+   */
+  isEmpty() {
+    return false;
+  }
+  /**
+   * Converts the bookmark node to an HTML representation.
+   *
+   * The output matches the CKEditor 5 bookmark contract so the value stays
+   * compatible with other editors and remains a valid local link target.
+   *
+   * @returns {string} - The HTML representation of the bookmark node.
+   */
+  toHtml() {
+    return `<a id="${escapeHtmlAttribute(this.name)}"></a>`;
+  }
+  /**
+   * Bookmarks do not accept text formatting, but still process selection annotations.
+   *
+   * @param {AnnotationAction} action - The annotation action to apply.
+   */
+  doAnnotationActionApply(action) {
+    // BoldAnnotationAction has no annotationType; deletion identifies BOLD through its annotationType.
+    if (action instanceof BoldAnnotationAction ||
+      (action instanceof DeleteNodeAnnotationAction &&
+        action.annotationType === NodeAnnotationTypeEnum.BOLD)) {
+      return;
+    }
+    super.doAnnotationActionApply(action);
+  }
+}
+RTEBookmarkNode.typeName = 'RTEBookmarkNode';
+RTEBookmarkNode.dtoName = 'RTEBookmarkNode';